use crate::EpiphanyWorkerLaunchDocument; use crate::RepoFrontierPlanMindContextProjection; use crate::agent_launch::{ EPIPHANY_IMAGINATION_OWNER_ROLE, EPIPHANY_IMAGINATION_ROLE_BINDING_ID, EPIPHANY_MIND_OWNER_ROLE, EPIPHANY_MIND_ROLE_BINDING_ID, EPIPHANY_MODELING_OWNER_ROLE, EPIPHANY_MODELING_ROLE_BINDING_ID, }; use crate::agent_memory::{ AGENT_MEMORY_SWARM_IDENTITY_KEY, AGENT_MEMORY_SWARM_IDENTITY_SCHEMA_VERSION, AGENT_MEMORY_SWARM_IDENTITY_TYPE, AGENT_MEMORY_TYPE, load_agent_memory_swarm_identity, }; use crate::continuity_gateway::ContinuityRecoveryReceipt; use crate::continuity_gateway::*; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE; use crate::eyes_gateway::EYES_EVIDENCE_PACKET_SCHEMA_VERSION; use crate::eyes_gateway::EYES_EVIDENCE_PACKET_TYPE; use crate::eyes_gateway::EYES_EVIDENCE_REFUSAL_RECEIPT_SCHEMA_VERSION; use crate::eyes_gateway::EYES_EVIDENCE_REFUSAL_RECEIPT_TYPE; use crate::eyes_gateway::EYES_EVIDENCE_REQUEST_SCHEMA_VERSION; use crate::eyes_gateway::EYES_EVIDENCE_REQUEST_TYPE; use crate::eyes_gateway::EYES_EVIDENCE_REVIEW_SCHEMA_VERSION; use crate::eyes_gateway::EYES_EVIDENCE_REVIEW_TYPE; use crate::eyes_gateway::EYES_SOURCE_LOOKUP_RECEIPT_SCHEMA_VERSION; use crate::eyes_gateway::EYES_SOURCE_LOOKUP_RECEIPT_TYPE; use crate::eyes_gateway::EyesEvidencePacket; use crate::hands_gateway::*; use crate::heartbeat_state::HEARTBEAT_STATE_SCHEMA_VERSION; use crate::heartbeat_state::HEARTBEAT_STATE_TYPE; use crate::memory_graph::MEMORY_GRAPH_SCHEMA_VERSION; use crate::memory_graph::MEMORY_GRAPH_TYPE; use crate::mind_gateway::MIND_GATEWAY_REVIEW_SCHEMA_VERSION; use crate::mind_gateway::MIND_GATEWAY_REVIEW_TYPE; use crate::mind_gateway::MIND_STATE_COMMIT_RECEIPT_SCHEMA_VERSION; use crate::mind_gateway::MIND_STATE_COMMIT_RECEIPT_TYPE; use crate::mind_gateway::MIND_STATE_EFFECT_PROPOSAL_SCHEMA_VERSION; use crate::mind_gateway::MIND_STATE_EFFECT_PROPOSAL_TYPE; use crate::mind_gateway::MIND_STATE_REJECTION_RECEIPT_SCHEMA_VERSION; use crate::mind_gateway::MIND_STATE_REJECTION_RECEIPT_TYPE; use crate::mind_gateway::MIND_THOUGHT_SCHEMA_VERSION; use crate::mind_gateway::MIND_THOUGHT_TYPE; use crate::mind_gateway::MIND_VERSE_ADOPTION_RECEIPT_SCHEMA_VERSION; use crate::mind_gateway::MIND_VERSE_ADOPTION_RECEIPT_TYPE; use crate::mind_gateway::MindGatewayDecision; use crate::mind_gateway::MindGatewayReview; use crate::mind_gateway::MindStateCommitReceipt; use crate::organ_dependencies::EpiphanyLaunchOrganContract; use crate::repo_model_gateway::{ REPO_FRONTIER_AUTONOMOUS_PROPOSAL_BINDING_CONTRACT, REPO_FRONTIER_AUTONOMOUS_PROPOSAL_BINDING_SCHEMA_VERSION, REPO_FRONTIER_HANDS_AUTHORITY_CONTRACT, REPO_FRONTIER_HANDS_AUTHORITY_SCHEMA_VERSION, REPO_FRONTIER_MODELING_REQUEST_CONTRACT, REPO_FRONTIER_MODELING_REQUEST_SCHEMA_VERSION, REPO_FRONTIER_PLAN_CANDIDATE_SCHEMA_VERSION, REPO_FRONTIER_PLAN_DECISION_CONTRACT, REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION, REPO_FRONTIER_PLAN_MIND_LAUNCH_BINDING_CONTRACT, REPO_FRONTIER_PLAN_MIND_LAUNCH_BINDING_SCHEMA_VERSION, REPO_FRONTIER_PLAN_MIND_REQUEST_CONTRACT, REPO_FRONTIER_PLAN_MIND_REQUEST_SCHEMA_VERSION, REPO_FRONTIER_PLANNING_CONTRACT, REPO_FRONTIER_PLANNING_LAUNCH_BINDING_CONTRACT, REPO_FRONTIER_PLANNING_LAUNCH_BINDING_SCHEMA_VERSION, REPO_FRONTIER_PLANNING_REQUEST_SCHEMA_VERSION, REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_CONTRACT, REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_SCHEMA_VERSION, REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_CONTRACT, REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION, REPO_FRONTIER_ROUTE_CONTRACT, REPO_FRONTIER_ROUTE_SCHEMA_VERSION, REPO_FRONTIER_WORK_PROPOSAL_CONTRACT, REPO_FRONTIER_WORK_PROPOSAL_SCHEMA_VERSION, REPO_MODEL_ADMISSION_CONTRACT, REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION, REPO_MODEL_ADMISSION_RECEIPT_TYPE, REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION, REPO_MODEL_ADMISSION_REVIEW_TYPE, REPO_MODEL_CLAIM_CHALLENGE_CONTRACT, REPO_MODEL_CLAIM_CHALLENGE_SCHEMA_VERSION, REPO_MODEL_CLAIM_REPAIR_REQUEST_CONTRACT, REPO_MODEL_CLAIM_REPAIR_REQUEST_SCHEMA_VERSION, REPO_MODEL_MIGRATION_CONTRACT, REPO_MODEL_MIGRATION_RECEIPT_SCHEMA_VERSION, REPO_MODEL_MIGRATION_RECEIPT_TYPE, RUNTIME_REPOSITORY_DOMAIN_BINDING_CONTRACT, RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY, RUNTIME_REPOSITORY_DOMAIN_BINDING_SCHEMA_VERSION, RepoFrontierAutonomousProposalBinding, RepoFrontierHandsAuthority, RepoFrontierModelingRequest, RepoFrontierNextOrgan, RepoFrontierPlanCandidate, RepoFrontierPlanDecision, RepoFrontierPlanDecisionReceipt, RepoFrontierPlanMindDecision, RepoFrontierPlanMindLaunchBinding, RepoFrontierPlanMindRequest, RepoFrontierPlanningCandidateEligibility, RepoFrontierPlanningEligibility, RepoFrontierPlanningLaunchBinding, RepoFrontierPlanningLifecycle, RepoFrontierPlanningLifecycleStage, RepoFrontierPlanningRequest, RepoFrontierProposalModelingLaunchBinding, RepoFrontierProposalModelingRequest, RepoFrontierRelinquishmentReceipt, RepoFrontierRoute, RepoFrontierVerdictDisposition, RepoFrontierWorkProposal, RepoModelAdmissionReceipt, RepoModelAdmissionReview, RepoModelClaimChallenge, RepoModelClaimRepairFrontierRef, RepoModelClaimRepairLaunchBinding, RepoModelClaimRepairRequest, RepoModelMigrationReceipt, RuntimeRepositoryDomainBinding, }; use crate::soul_gateway::SoulVerdictReceipt; use crate::soul_gateway::*; use crate::state_ledger::STATE_LEDGER_SCHEMA_VERSION; use crate::state_ledger::STATE_LEDGER_STORE_TYPE; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REVIEW_SCHEMA_VERSION; use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE; use crate::substrate_gate::SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_SCHEMA_VERSION; use crate::substrate_gate::SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE; use crate::substrate_gate::SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION; use crate::substrate_gate::SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE; use crate::substrate_gate::SubstrateGateRepoAccessGrantReceipt; use crate::thread_state_store::THREAD_STATE_SCHEMA_VERSION; use crate::thread_state_store::THREAD_STATE_TYPE; use anyhow::Context; use anyhow::Result; use anyhow::anyhow; use cultcache_rs::CacheBackingStore; use cultcache_rs::CultCache; use cultcache_rs::CultCacheEnvelope; use cultcache_rs::DatabaseEntry; use cultcache_rs::SingleFileMessagePackBackingStore; use cultnet_rs::CultNetDocumentMutationContract; use cultnet_rs::CultNetDocumentOperation; use cultnet_rs::CultNetMessage; use cultnet_rs::CultNetMutationAuthority; use cultnet_rs::CultNetSchemaKind; use cultnet_rs::CultNetSchemaRegistration; use cultnet_rs::CultNetSchemaRegistry; use cultnet_rs::CultNetWireContract; use cultnet_rs::builtin_schema_registry; use cultnet_rs::encode_cultnet_message_to_vec; use cultnet_rs::encode_frame; use epiphany_model_adapter::EpiphanyModelAdapterStatus; use epiphany_model_adapter::EpiphanyModelReceipt; use epiphany_model_adapter::EpiphanyModelRequest; use epiphany_model_adapter::EpiphanyModelStreamEvent; use epiphany_openai_adapter::EpiphanyOpenAiAdapterStatus; use epiphany_openai_adapter::EpiphanyOpenAiModelReceipt; use epiphany_openai_adapter::EpiphanyOpenAiModelRequest; use epiphany_openai_adapter::EpiphanyOpenAiStreamEvent; use epiphany_state_model::EpiphanyJobBinding; use epiphany_state_model::EpiphanyJobKind; use epiphany_state_model::EpiphanyRuntimeLink; use epiphany_state_model::EpiphanyThreadState; use epiphany_tool_adapter::EpiphanyToolCapability; use epiphany_tool_adapter::EpiphanyToolInvocationIntent; use epiphany_tool_adapter::EpiphanyToolInvocationReceipt; use serde::Deserialize; use serde::Serialize; use sha2::Digest; use sha2::Sha256; use std::collections::BTreeMap; use std::collections::BTreeSet; use std::fs; use std::path::Path; use std::path::PathBuf; pub const RUNTIME_IDENTITY_TYPE: &str = "epiphany.runtime.identity"; pub const RUNTIME_SESSION_TYPE: &str = "epiphany.runtime.session"; pub const RUNTIME_JOB_TYPE: &str = "epiphany.runtime.job"; pub const RUNTIME_WORKER_LAUNCH_REQUEST_TYPE: &str = "epiphany.runtime.worker_launch_request"; pub const RUNTIME_ROLE_WORKER_RESULT_TYPE: &str = "epiphany.runtime.role_worker_result"; pub const RUNTIME_REORIENT_WORKER_RESULT_TYPE: &str = "epiphany.runtime.reorient_worker_result"; pub const RUNTIME_JOB_RESULT_TYPE: &str = "epiphany.runtime.job_result"; pub const RUNTIME_EVENT_TYPE: &str = "epiphany.runtime.event"; pub const COORDINATOR_RUN_RECEIPT_TYPE: &str = "epiphany.coordinator_run_receipt.v0"; pub const OPENAI_ADAPTER_STATUS_TYPE: &str = "epiphany.openai_adapter_status.v0"; pub const OPENAI_MODEL_REQUEST_TYPE: &str = "epiphany.openai_model_request.v0"; pub const OPENAI_MODEL_STREAM_EVENT_TYPE: &str = "epiphany.openai_model_stream_event.v0"; pub const OPENAI_MODEL_RECEIPT_TYPE: &str = "epiphany.openai_model_receipt.v0"; pub const MODEL_ADAPTER_STATUS_TYPE: &str = "epiphany.model_adapter_status.v0"; pub const MODEL_REQUEST_TYPE: &str = "epiphany.model_request.v0"; pub const MODEL_STREAM_EVENT_TYPE: &str = "epiphany.model_stream_event.v0"; pub const MODEL_RECEIPT_TYPE: &str = "epiphany.model_receipt.v0"; pub const TOOL_CAPABILITY_TYPE: &str = "epiphany.tool_capability.v0"; pub const TOOL_INVOCATION_INTENT_TYPE: &str = "epiphany.tool_invocation_intent.v0"; pub const TOOL_INVOCATION_RECEIPT_TYPE: &str = "epiphany.tool_invocation_receipt.v0"; pub const RUNTIME_IDENTITY_KEY: &str = "self"; pub const RUNTIME_SWARM_BINDING_TYPE: &str = "epiphany.runtime.swarm_binding"; pub const RUNTIME_SWARM_BINDING_KEY: &str = "runtime-swarm-binding"; pub const RUNTIME_SWARM_BINDING_SCHEMA_VERSION: &str = "epiphany.runtime.swarm_binding.v0"; pub const RUNTIME_SPINE_SCHEMA_VERSION: &str = "epiphany.runtime_spine.v0"; pub const RUNTIME_WORKER_LAUNCH_REQUEST_SCHEMA_VERSION: &str = "epiphany.runtime.worker_launch_request.v1"; pub const RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION: &str = "epiphany.runtime.role_worker_result.v3"; pub const RUNTIME_REORIENT_WORKER_RESULT_SCHEMA_VERSION: &str = "epiphany.runtime.reorient_worker_result.v0"; pub const COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION: &str = "epiphany.coordinator_run_receipt.v0"; pub const OPENAI_ADAPTER_STATUS_SCHEMA_VERSION: &str = "epiphany.openai_adapter_status.v0"; pub const OPENAI_MODEL_REQUEST_SCHEMA_VERSION: &str = "epiphany.openai_model_request.v0"; pub const OPENAI_MODEL_STREAM_EVENT_SCHEMA_VERSION: &str = "epiphany.openai_model_stream_event.v0"; pub const OPENAI_MODEL_RECEIPT_SCHEMA_VERSION: &str = "epiphany.openai_model_receipt.v0"; pub const MODEL_ADAPTER_STATUS_SCHEMA_VERSION: &str = "epiphany.model_adapter_status.v0"; pub const MODEL_REQUEST_SCHEMA_VERSION: &str = "epiphany.model_request.v0"; pub const MODEL_STREAM_EVENT_SCHEMA_VERSION: &str = "epiphany.model_stream_event.v0"; pub const MODEL_RECEIPT_SCHEMA_VERSION: &str = "epiphany.model_receipt.v0"; pub const TOOL_CAPABILITY_SCHEMA_VERSION: &str = "epiphany.tool_capability.v0"; pub const TOOL_INVOCATION_INTENT_SCHEMA_VERSION: &str = "epiphany.tool_invocation_intent.v0"; pub const TOOL_INVOCATION_RECEIPT_SCHEMA_VERSION: &str = "epiphany.tool_invocation_receipt.v0"; pub const AGENT_MEMORY_PAYLOAD_SCHEMA_VERSION: &str = "epiphany.agent_memory.v0"; pub const CULTNET_SCHEMA_INDEX_RELATIVE: &str = "schemas/cultnet/index.json"; #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] #[serde(rename_all = "camelCase")] struct EpiphanyCultNetSchemaIndex { schema_version: String, schemas: Vec, } #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] #[serde(rename_all = "camelCase")] struct EpiphanyCultNetSchemaIndexEntry { schema_id: String, kind: CultNetSchemaKind, wire_contracts: Vec, #[serde(default)] schema_version: Option, #[serde(default)] document_type: Option, #[serde(default)] title: Option, path: String, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache(type = "epiphany.runtime.identity", schema = "EpiphanyRuntimeIdentity")] pub struct EpiphanyRuntimeIdentity { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub runtime_id: String, #[cultcache(key = 2)] pub display_name: String, #[cultcache(key = 3)] pub runtime_kind: String, #[cultcache(key = 4)] pub created_at: String, #[cultcache(key = 5)] pub updated_at: String, #[cultcache(key = 6)] pub supported_document_types: Vec, #[cultcache(key = 7, default)] pub metadata: BTreeMap, } #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] #[cultcache( type = "epiphany.runtime.swarm_binding", schema = "EpiphanyRuntimeSwarmBinding" )] pub struct EpiphanyRuntimeSwarmBinding { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub binding_id: String, #[cultcache(key = 2)] pub runtime_id: String, #[cultcache(key = 3)] pub swarm_id: String, #[cultcache(key = 4)] pub source_identity_type: String, #[cultcache(key = 5)] pub source_identity_key: String, #[cultcache(key = 6)] pub source_identity_sha256: String, #[cultcache(key = 7)] pub bound_at: String, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache(type = "epiphany.runtime.session", schema = "EpiphanyRuntimeSession")] pub struct EpiphanyRuntimeSession { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub session_id: String, #[cultcache(key = 2)] pub objective: String, #[cultcache(key = 3)] pub status: EpiphanyRuntimeSessionStatus, #[cultcache(key = 4)] pub created_at: String, #[cultcache(key = 5)] pub updated_at: String, #[cultcache(key = 6, default)] pub coordinator_note: String, #[cultcache(key = 7, default)] pub metadata: BTreeMap, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache(type = "epiphany.runtime.job", schema = "EpiphanyRuntimeJob")] pub struct EpiphanyRuntimeJob { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub job_id: String, #[cultcache(key = 2)] pub session_id: String, #[cultcache(key = 3)] pub role: String, #[cultcache(key = 4)] pub status: EpiphanyRuntimeJobStatus, #[cultcache(key = 5)] pub created_at: String, #[cultcache(key = 6)] pub updated_at: String, #[cultcache(key = 7, default)] pub summary: String, #[cultcache(key = 8, default)] pub artifact_refs: Vec, #[cultcache(key = 9, default)] pub metadata: BTreeMap, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "epiphany.runtime.worker_launch_request", schema = "EpiphanyRuntimeWorkerLaunchRequest" )] pub struct EpiphanyRuntimeWorkerLaunchRequest { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub job_id: String, #[cultcache(key = 2)] pub binding_id: String, #[cultcache(key = 3)] pub role: String, #[cultcache(key = 4)] pub authority_scope: String, #[cultcache(key = 5)] pub instruction: String, #[cultcache(key = 6)] pub output_contract_id: String, #[cultcache(key = 7)] pub document_kind: String, #[cultcache(key = 8)] pub launch_document_msgpack: Vec, #[cultcache(key = 9, default)] pub metadata: BTreeMap, #[cultcache(key = 10, default)] pub organ_launch_contract: EpiphanyLaunchOrganContract, #[cultcache(key = 11, default)] pub proposal_modeling_request_id: Option, #[cultcache(key = 12, default)] pub claim_repair_request_id: Option, #[cultcache(key = 13, default)] pub frontier_planning_request_id: Option, #[cultcache(key = 14, default)] pub frontier_plan_mind_request_id: Option, #[cultcache(key = 15, default)] pub imagination_consideration_request_id: Option, #[cultcache(key = 16, default)] pub admitted_model_direction_consideration_request_id: Option, } impl EpiphanyRuntimeWorkerLaunchRequest { pub fn launch_document(&self) -> Result { let document: EpiphanyWorkerLaunchDocument = rmp_serde::from_slice(&self.launch_document_msgpack) .context("failed to decode worker launch document MessagePack")?; let actual_kind = worker_launch_document_kind(&document); if actual_kind != self.document_kind { return Err(anyhow!( "worker launch document kind mismatch: indexed {:?}, payload {:?}", self.document_kind, actual_kind )); } Ok(document) } pub fn repository_body_observation_basis( &self, ) -> Result> { Ok(match self.launch_document()? { EpiphanyWorkerLaunchDocument::Role(document) => { document.repository_body_observation_basis } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }) } } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "epiphany.runtime.role_worker_result", schema = "EpiphanyRuntimeRoleWorkerResult" )] pub struct EpiphanyRuntimeRoleWorkerResult { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub result_id: String, #[cultcache(key = 2)] pub job_id: String, #[cultcache(key = 3)] pub role_id: String, #[cultcache(key = 4)] pub verdict: String, #[cultcache(key = 5)] pub summary: String, #[cultcache(key = 6)] pub next_safe_move: String, #[cultcache(key = 7, default)] pub checkpoint_summary: Option, #[cultcache(key = 8, default)] pub scratch_summary: Option, #[cultcache(key = 9, default)] pub files_inspected: Vec, #[cultcache(key = 10, default)] pub frontier_node_ids: Vec, #[cultcache(key = 11, default)] pub evidence_ids: Vec, #[cultcache(key = 12, default)] pub artifact_refs: Vec, #[cultcache(key = 13, default)] pub open_questions: Vec, #[cultcache(key = 14, default)] pub evidence_gaps: Vec, #[cultcache(key = 15, default)] pub risks: Vec, #[cultcache(key = 16, default)] pub state_patch_msgpack: Option>, #[cultcache(key = 17, default)] pub self_patch_msgpack: Option>, #[cultcache(key = 18, default)] pub item_error: Option, #[cultcache(key = 19, default)] pub metadata: BTreeMap, #[cultcache(key = 20, default)] pub repo_model_patch_msgpack: Option>, #[cultcache(key = 21, default)] pub verification_request_id: Option, #[cultcache(key = 22, default)] pub frontier_route_id: Option, #[cultcache(key = 23, default)] pub repo_frontier_modeling_request_id: Option, #[cultcache(key = 24, default)] pub proposal_modeling_request_id: Option, #[cultcache(key = 25, default)] pub claim_repair_request_id: Option, #[cultcache(key = 26, default)] pub frontier_planning_request_id: Option, #[cultcache(key = 27, default)] pub frontier_plan_candidate_msgpack: Option>, #[cultcache(key = 28, default)] pub frontier_plan_mind_request_id: Option, #[cultcache(key = 29, default)] pub frontier_plan_mind_decision_msgpack: Option>, #[cultcache(key = 30, default)] pub repository_body_observation_basis: Option, #[cultcache(key = 31, default)] pub imagination_consideration_request_id: Option, #[cultcache(key = 32, default)] pub imagination_consideration_candidate_msgpack: Option>, #[cultcache(key = 33, default)] pub admitted_model_direction_consideration_request_id: Option, #[cultcache(key = 34, default)] pub admitted_model_direction_consideration_result_msgpack: Option>, } impl EpiphanyRuntimeRoleWorkerResult { pub fn state_patch(&self) -> Result> { decode_optional_msgpack( self.state_patch_msgpack.as_deref(), "role worker statePatch", ) } pub fn self_patch(&self) -> Result> { decode_optional_msgpack(self.self_patch_msgpack.as_deref(), "role worker selfPatch") } pub fn repo_model_patch(&self) -> Result> { decode_optional_msgpack( self.repo_model_patch_msgpack.as_deref(), "role worker repoModelPatch", ) } pub fn frontier_plan_candidate(&self) -> Result> { decode_optional_msgpack( self.frontier_plan_candidate_msgpack.as_deref(), "role worker frontierPlanCandidate", ) } pub fn frontier_plan_mind_decision(&self) -> Result> { decode_optional_msgpack( self.frontier_plan_mind_decision_msgpack.as_deref(), "role worker frontierPlanMindDecision", ) } pub fn imagination_consideration_candidate( &self, ) -> Result> { decode_optional_msgpack( self.imagination_consideration_candidate_msgpack.as_deref(), "role worker imaginationConsiderationCandidate", ) } pub fn admitted_model_direction_consideration_result( &self, ) -> Result> { decode_optional_msgpack( self.admitted_model_direction_consideration_result_msgpack .as_deref(), "role worker admittedModelDirectionConsiderationResult", ) } } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "epiphany.runtime.reorient_worker_result", schema = "EpiphanyRuntimeReorientWorkerResult" )] pub struct EpiphanyRuntimeReorientWorkerResult { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub result_id: String, #[cultcache(key = 2)] pub job_id: String, #[cultcache(key = 3)] pub mode: String, #[cultcache(key = 4)] pub summary: String, #[cultcache(key = 5)] pub next_safe_move: String, #[cultcache(key = 6, default)] pub checkpoint_still_valid: Option, #[cultcache(key = 7, default)] pub files_inspected: Vec, #[cultcache(key = 8, default)] pub frontier_node_ids: Vec, #[cultcache(key = 9, default)] pub evidence_ids: Vec, #[cultcache(key = 10, default)] pub artifact_refs: Vec, #[cultcache(key = 11, default)] pub open_questions: Vec, #[cultcache(key = 12, default)] pub continuity_risks: Vec, #[cultcache(key = 13, default)] pub item_error: Option, #[cultcache(key = 14, default)] pub metadata: BTreeMap, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "epiphany.runtime.job_result", schema = "EpiphanyRuntimeJobResult" )] pub struct EpiphanyRuntimeJobResult { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub result_id: String, #[cultcache(key = 2)] pub job_id: String, #[cultcache(key = 3)] pub session_id: String, #[cultcache(key = 4)] pub role: String, #[cultcache(key = 5)] pub verdict: String, #[cultcache(key = 6)] pub summary: String, #[cultcache(key = 7)] pub completed_at: String, #[cultcache(key = 8, default)] pub next_safe_move: String, #[cultcache(key = 9, default)] pub evidence_refs: Vec, #[cultcache(key = 10, default)] pub artifact_refs: Vec, #[cultcache(key = 11, default)] pub metadata: BTreeMap, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache(type = "epiphany.runtime.event", schema = "EpiphanyRuntimeEvent")] pub struct EpiphanyRuntimeEvent { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub event_id: String, #[cultcache(key = 2)] pub occurred_at: String, #[cultcache(key = 3)] pub event_type: String, #[cultcache(key = 4)] pub source: String, #[cultcache(key = 5, default)] pub session_id: Option, #[cultcache(key = 6, default)] pub job_id: Option, #[cultcache(key = 7, default)] pub summary: String, #[cultcache(key = 8, default)] pub metadata: BTreeMap, } #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "epiphany.coordinator_run_receipt.v0", schema = "EpiphanyCoordinatorRunReceipt" )] pub struct EpiphanyCoordinatorRunReceipt { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] pub receipt_id: String, #[cultcache(key = 2)] pub session_id: String, #[cultcache(key = 3)] pub thread_id: String, #[cultcache(key = 4)] pub mode: String, #[cultcache(key = 5)] pub status: String, #[cultcache(key = 6)] pub final_action: String, #[cultcache(key = 7, default)] pub final_reason: Option, #[cultcache(key = 8)] pub step_count: u64, #[cultcache(key = 9)] pub created_at: String, #[cultcache(key = 10, default)] pub model_provider: Option, #[cultcache(key = 11, default)] pub runtime_store: String, #[cultcache(key = 12, default)] pub artifact_refs: Vec, #[cultcache(key = 13, default)] pub sealed_artifact_refs: Vec, #[cultcache(key = 14, default)] pub metadata: BTreeMap, #[cultcache(key = 15, default)] pub resident_grant_id: Option, #[cultcache(key = 16, default)] pub resident_launch_digest: Option, #[cultcache(key = 17, default)] pub resident_policy_digest: Option, #[cultcache(key = 18, default)] pub resident_argv_digest: Option, #[cultcache(key = 19, default)] pub resident_objective_digest: Option, #[cultcache(key = 20, default)] pub resident_release_commit: Option, #[cultcache(key = 21, default)] pub resident_release_manifest_digest: Option, #[cultcache(key = 22, default)] pub resident_executable_digest: Option, } #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub enum EpiphanyRuntimeSessionStatus { #[default] Proposed, Active, WaitingForReview, Sleeping, Completed, Archived, } #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub enum EpiphanyRuntimeJobStatus { #[default] Queued, Running, WaitingForReview, Completed, Failed, Cancelled, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct EpiphanyRuntimeSpineStatus { pub store: String, pub present: bool, pub runtime_id: Option, pub display_name: Option, pub sessions: usize, pub active_sessions: usize, pub jobs: usize, pub open_jobs: usize, pub job_results: usize, pub events: usize, pub tool_invocation_intents: usize, pub tool_invocation_receipts: usize, pub pending_tool_invocations: usize, pub supported_document_types: Vec, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct EpiphanyToolInvocationStatus { pub intent_id: String, pub adapter: String, pub server: String, pub tool_name: String, pub call_id: Option, pub model_request_id: Option, pub caller: String, pub reason: String, pub created_at: String, pub status: String, pub receipt_id: Option, pub completed_at: Option, pub error: Option, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RuntimeSpineInitOptions { pub runtime_id: String, pub display_name: String, pub created_at: String, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RuntimeSpineSessionOptions { pub session_id: String, pub objective: String, pub created_at: String, pub coordinator_note: String, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RuntimeSpineEventOptions { pub event_id: String, pub occurred_at: String, pub event_type: String, pub source: String, pub session_id: Option, pub job_id: Option, pub summary: String, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RuntimeSpineJobOptions { pub job_id: String, pub session_id: String, pub role: String, pub created_at: String, pub summary: String, pub artifact_refs: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RuntimeSpineJobResultOptions { pub result_id: String, pub job_id: String, pub completed_at: String, pub verdict: String, pub summary: String, pub next_safe_move: String, pub evidence_refs: Vec, pub artifact_refs: Vec, } #[derive(Clone, Debug, PartialEq)] pub struct RuntimeSpineHeartbeatJobOptions { pub runtime_id: String, pub display_name: String, pub session_id: String, pub objective: String, pub coordinator_note: String, pub job_id: String, pub role: String, pub binding_id: String, pub authority_scope: String, pub instruction: String, pub launch_document: EpiphanyWorkerLaunchDocument, pub output_contract_id: String, pub organ_launch_contract: EpiphanyLaunchOrganContract, pub proposal_modeling_request_id: Option, pub claim_repair_request_id: Option, pub frontier_planning_request_id: Option, pub frontier_plan_mind_request_id: Option, pub imagination_consideration_request_id: Option, pub admitted_model_direction_consideration_request_id: Option, pub created_at: String, } #[derive(Clone, Debug, PartialEq)] pub struct PreparedRuntimeSpineHeartbeatJob { pub job: EpiphanyRuntimeJob, pub envelopes: Vec, } #[derive(Clone, Debug, PartialEq)] pub struct RuntimeSpineHeartbeatLaunchPlanOptions { pub binding_id: String, pub kind: EpiphanyJobKind, pub scope: String, pub owner_role: String, pub authority_scope: String, pub linked_subgoal_ids: Vec, pub linked_graph_node_ids: Vec, pub instruction: String, pub launch_document: EpiphanyWorkerLaunchDocument, pub output_contract_id: String, pub organ_launch_contract: EpiphanyLaunchOrganContract, pub max_runtime_seconds: Option, pub runtime_job_id: String, } #[derive(Clone, Debug, PartialEq)] pub struct RuntimeSpineHeartbeatLaunchPlan { pub binding: EpiphanyJobBinding, pub runtime_link: EpiphanyRuntimeLink, } #[derive(Debug, Clone, PartialEq)] pub struct EpiphanyJobLaunchRequest { pub expected_revision: Option, pub binding_id: String, pub kind: EpiphanyJobKind, pub scope: String, pub owner_role: String, pub authority_scope: String, pub linked_subgoal_ids: Vec, pub linked_graph_node_ids: Vec, pub instruction: String, pub launch_document: EpiphanyWorkerLaunchDocument, pub output_contract_id: String, pub organ_launch_contract: EpiphanyLaunchOrganContract, pub max_runtime_seconds: Option, pub proposal_modeling_request_id: Option, pub claim_repair_request_id: Option, pub frontier_planning_request_id: Option, pub frontier_plan_mind_request_id: Option, pub imagination_consideration_request_id: Option, pub admitted_model_direction_consideration_request_id: Option, } #[derive(Debug, Clone, PartialEq)] pub struct EpiphanyJobLaunchResult { pub epiphany_state: EpiphanyThreadState, pub binding_id: String, pub launcher_job_id: String, pub backend_job_id: String, } #[derive(Debug, Clone, PartialEq, Eq)] pub struct EpiphanyJobInterruptRequest { pub expected_revision: Option, pub binding_id: String, pub reason: Option, } #[derive(Debug, Clone, PartialEq)] pub struct EpiphanyJobInterruptResult { pub epiphany_state: EpiphanyThreadState, pub binding_id: String, pub cancel_requested: bool, pub interrupted_thread_ids: Vec, } #[derive(Clone, Debug, PartialEq)] pub struct EpiphanyRuntimeJobSnapshot { pub job: EpiphanyRuntimeJob, pub result: Option, } pub fn runtime_spine_cache(store_path: impl AsRef) -> Result { let store_path = store_path.as_ref(); let mut cache = CultCache::new(); cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new( store_path.to_path_buf(), )); Ok(cache) } pub fn initialize_runtime_spine( store_path: impl AsRef, options: RuntimeSpineInitOptions, ) -> Result { validate_non_empty(&options.runtime_id, "runtime id")?; validate_non_empty(&options.display_name, "display name")?; validate_non_empty(&options.created_at, "created at")?; let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let existing = cache.get::(RUNTIME_IDENTITY_KEY)?; let created_at = existing .as_ref() .map(|identity| identity.created_at.clone()) .unwrap_or_else(|| options.created_at.clone()); let identity = EpiphanyRuntimeIdentity { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), runtime_id: options.runtime_id, display_name: options.display_name, runtime_kind: "epiphany.native".to_string(), created_at, updated_at: options.created_at, supported_document_types: runtime_registered_document_types(), metadata: BTreeMap::from([("codexEvacuationBridge".to_string(), "temporary".to_string())]), }; cache.put(RUNTIME_IDENTITY_KEY, &identity)?; Ok(identity) } pub fn bind_runtime_to_agent_memory_swarm( runtime_store: impl AsRef, agent_store: impl AsRef, bound_at: &str, ) -> Result { chrono::DateTime::parse_from_rfc3339(bound_at) .map_err(|_| anyhow!("runtime swarm binding timestamp must be RFC3339"))?; let source = load_agent_memory_swarm_identity(agent_store)? .ok_or_else(|| anyhow!("agent memory store has no canonical swarm identity"))?; if source.schema_version != AGENT_MEMORY_SWARM_IDENTITY_SCHEMA_VERSION { return Err(anyhow!("unsupported canonical agent-memory swarm identity")); } let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let identity = cache .get::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("runtime swarm binding requires runtime identity"))?; let binding = EpiphanyRuntimeSwarmBinding { schema_version: RUNTIME_SWARM_BINDING_SCHEMA_VERSION.to_string(), binding_id: RUNTIME_SWARM_BINDING_KEY.to_string(), runtime_id: identity.runtime_id.clone(), swarm_id: source.swarm_id.clone(), source_identity_type: AGENT_MEMORY_SWARM_IDENTITY_TYPE.to_string(), source_identity_key: AGENT_MEMORY_SWARM_IDENTITY_KEY.to_string(), source_identity_sha256: format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&source)?)), bound_at: bound_at.to_string(), }; if let Some(existing) = cache.get::(RUNTIME_SWARM_BINDING_KEY)? { return if existing.schema_version == binding.schema_version && existing.binding_id == binding.binding_id && existing.runtime_id == binding.runtime_id && existing.swarm_id == binding.swarm_id && existing.source_identity_type == binding.source_identity_type && existing.source_identity_key == binding.source_identity_key && existing.source_identity_sha256 == binding.source_identity_sha256 { Ok(existing) } else { Err(anyhow!("runtime swarm binding identity collision")) }; } let backing = SingleFileMessagePackBackingStore::new(runtime_store); let identity_envelope = backing .pull_all()? .into_iter() .find(|entry| entry.r#type == RUNTIME_IDENTITY_TYPE && entry.key == RUNTIME_IDENTITY_KEY) .ok_or_else(|| anyhow!("runtime swarm binding lost runtime identity envelope"))?; let (binding_envelope, _) = cache.prepare_entry(RUNTIME_SWARM_BINDING_KEY, &binding)?; if backing.compare_and_swap_batch( &[identity_envelope.clone()], vec![identity_envelope, binding_envelope], )? { return Ok(binding); } let mut reloaded = runtime_spine_cache(runtime_store)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(RUNTIME_SWARM_BINDING_KEY)? { Some(existing) if existing == binding => Ok(existing), _ => Err(anyhow!("runtime swarm binding lost immutable CAS")), } } pub fn runtime_swarm_binding( runtime_store: impl AsRef, ) -> Result> { let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; cache.get(RUNTIME_SWARM_BINDING_KEY) } fn require_runtime_swarm_binding(cache: &CultCache) -> Result { let identity = require_identity(cache)?; let binding = cache .get::(RUNTIME_SWARM_BINDING_KEY)? .ok_or_else(|| anyhow!("RepoModel admission requires immutable runtime swarm binding"))?; if binding.schema_version != RUNTIME_SWARM_BINDING_SCHEMA_VERSION || binding.binding_id != RUNTIME_SWARM_BINDING_KEY || binding.runtime_id != identity.runtime_id || binding.swarm_id.trim().is_empty() || binding.source_identity_type != AGENT_MEMORY_SWARM_IDENTITY_TYPE || binding.source_identity_key != AGENT_MEMORY_SWARM_IDENTITY_KEY || binding.source_identity_sha256.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&binding.bound_at).is_err() { return Err(anyhow!("runtime swarm binding is invalid")); } Ok(binding) } fn modeling_projection_obligation( cache: &CultCache, snapshot: &crate::EpiphanyMemoryGraphSnapshot, source_commit_id: &str, created_at: &str, ) -> Result { let binding = require_runtime_swarm_binding(cache)?; crate::derive_memory_semantic_projection_obligation( snapshot, &binding.swarm_id, crate::SemanticPartition::Modeling, &format!("epiphany.runtime/{}/repo-model", binding.runtime_id), source_commit_id, created_at, ) } fn require_modeling_projection_obligation_for_commit( cache: &CultCache, source_commit_id: &str, source_generation: u64, source_model_hash: &str, created_at: &str, ) -> Result { let binding = require_runtime_swarm_binding(cache)?; let canonical_source_id = format!("epiphany.runtime/{}/repo-model", binding.runtime_id); let matches = cache .get_all::()? .into_iter() .filter(|obligation| obligation.source_commit_id == source_commit_id) .collect::>(); if matches.len() != 1 { return Err(anyhow!( "RepoModel commit requires exactly one semantic projection obligation" )); } let obligation = matches.into_iter().next().expect("one obligation"); crate::validate_memory_semantic_projection_obligation(&obligation)?; if obligation.swarm_id != binding.swarm_id || obligation.partition != "modeling" || obligation.canonical_source_id != canonical_source_id || obligation.source_generation != source_generation || obligation.source_model_hash != source_model_hash || obligation.created_at != created_at { return Err(anyhow!( "RepoModel semantic projection obligation collision" )); } Ok(obligation) } pub fn create_runtime_session( store_path: impl AsRef, options: RuntimeSpineSessionOptions, ) -> Result { validate_non_empty(&options.session_id, "session id")?; validate_non_empty(&options.objective, "objective")?; validate_non_empty(&options.created_at, "created at")?; let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; require_identity(&cache)?; if cache .get::(&options.session_id)? .is_some() { return Err(anyhow!( "runtime session {:?} already exists", options.session_id )); } let session = EpiphanyRuntimeSession { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), session_id: options.session_id.clone(), objective: options.objective, status: EpiphanyRuntimeSessionStatus::Active, created_at: options.created_at.clone(), updated_at: options.created_at, coordinator_note: options.coordinator_note, metadata: BTreeMap::new(), }; cache.put(&options.session_id, &session)?; Ok(session) } pub fn ensure_runtime_session( store_path: impl AsRef, options: RuntimeSpineSessionOptions, ) -> Result { validate_non_empty(&options.session_id, "session id")?; validate_non_empty(&options.objective, "objective")?; validate_non_empty(&options.created_at, "created at")?; let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; require_identity(&cache)?; if let Some(existing) = cache.get::(&options.session_id)? { if matches!( existing.status, EpiphanyRuntimeSessionStatus::Completed | EpiphanyRuntimeSessionStatus::Archived ) { return Err(anyhow!( "runtime session {:?} is terminal and cannot accept jobs", options.session_id )); } return Ok(existing); } let session = EpiphanyRuntimeSession { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), session_id: options.session_id.clone(), objective: options.objective, status: EpiphanyRuntimeSessionStatus::Active, created_at: options.created_at.clone(), updated_at: options.created_at, coordinator_note: options.coordinator_note, metadata: BTreeMap::new(), }; cache.put(&options.session_id, &session)?; Ok(session) } pub fn create_runtime_job( store_path: impl AsRef, options: RuntimeSpineJobOptions, ) -> Result { validate_non_empty(&options.job_id, "job id")?; validate_non_empty(&options.session_id, "session id")?; validate_non_empty(&options.role, "role")?; validate_non_empty(&options.created_at, "created at")?; let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let session = cache .get::(&options.session_id)? .ok_or_else(|| anyhow!("runtime session {:?} does not exist", options.session_id))?; if matches!( session.status, EpiphanyRuntimeSessionStatus::Completed | EpiphanyRuntimeSessionStatus::Archived ) { return Err(anyhow!( "runtime session {:?} is not open for jobs", options.session_id )); } if cache.get::(&options.job_id)?.is_some() { return Err(anyhow!("runtime job {:?} already exists", options.job_id)); } let job = EpiphanyRuntimeJob { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), job_id: options.job_id.clone(), session_id: options.session_id.clone(), role: options.role, status: EpiphanyRuntimeJobStatus::Queued, created_at: options.created_at.clone(), updated_at: options.created_at.clone(), summary: options.summary, artifact_refs: options.artifact_refs, metadata: BTreeMap::new(), }; cache.put(&options.job_id, &job)?; let event = EpiphanyRuntimeEvent { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), event_id: format!("event-job-opened-{}", options.job_id), occurred_at: options.created_at, event_type: "job.opened".to_string(), source: "runtime-spine".to_string(), session_id: Some(options.session_id), job_id: Some(options.job_id), summary: "Native runtime job opened.".to_string(), metadata: BTreeMap::new(), }; cache.put(&event.event_id, &event)?; Ok(job) } pub fn plan_runtime_spine_heartbeat_launch( state: &EpiphanyThreadState, options: RuntimeSpineHeartbeatLaunchPlanOptions, ) -> Result { validate_heartbeat_launch_options(state, &options)?; Ok(RuntimeSpineHeartbeatLaunchPlan { binding: EpiphanyJobBinding { id: options.binding_id.clone(), kind: options.kind, scope: options.scope.clone(), owner_role: options.owner_role.clone(), authority_scope: Some(options.authority_scope.clone()), linked_subgoal_ids: options.linked_subgoal_ids.clone(), linked_graph_node_ids: options.linked_graph_node_ids.clone(), blocking_reason: None, }, runtime_link: EpiphanyRuntimeLink { id: format!( "runtime-link-{}-{}", options.binding_id, options.runtime_job_id ), binding_id: options.binding_id, surface: "jobLaunch".to_string(), role_id: options.owner_role, authority_scope: options.authority_scope, runtime_job_id: options.runtime_job_id, runtime_result_id: None, linked_subgoal_ids: options.linked_subgoal_ids, linked_graph_node_ids: options.linked_graph_node_ids, }, }) } pub fn replace_or_append_epiphany_job_binding( mut bindings: Vec, replacement: EpiphanyJobBinding, ) -> Vec { if let Some(existing) = bindings .iter_mut() .find(|binding| binding.id == replacement.id) { *existing = replacement; return bindings; } bindings.push(replacement); bindings } pub fn clear_epiphany_job_binding_backend( mut bindings: Vec, binding_index: usize, blocking_reason: &str, ) -> Vec { let binding = &mut bindings[binding_index]; binding.blocking_reason = Some(blocking_reason.to_string()); bindings } pub fn open_runtime_spine_heartbeat_job( store_path: impl AsRef, options: RuntimeSpineHeartbeatJobOptions, ) -> Result { validate_non_empty(&options.runtime_id, "runtime id")?; validate_non_empty(&options.display_name, "display name")?; validate_non_empty(&options.session_id, "session id")?; validate_non_empty(&options.objective, "objective")?; validate_non_empty(&options.job_id, "job id")?; validate_non_empty(&options.role, "role")?; validate_repository_body_launch_carrier(&options.role, &options.launch_document)?; validate_proposal_modeling_launch_carrier( &options.role, &options.binding_id, options.proposal_modeling_request_id.as_deref(), &options.launch_document, )?; validate_claim_repair_launch_carrier( &options.role, &options.binding_id, options.claim_repair_request_id.as_deref(), &options.launch_document, )?; validate_frontier_planning_launch_carrier( &options.role, &options.binding_id, options.frontier_planning_request_id.as_deref(), &options.launch_document, )?; validate_imagination_consideration_launch_carrier( &options.role, &options.binding_id, options.imagination_consideration_request_id.as_deref(), &options.launch_document, )?; validate_non_empty(&options.binding_id, "binding id")?; validate_non_empty(&options.authority_scope, "authority scope")?; validate_non_empty(&options.instruction, "instruction")?; validate_non_empty( options.launch_document.thread_id(), "worker launch document thread id", )?; validate_non_empty(&options.output_contract_id, "output contract id")?; if options.output_contract_id != options.launch_document.output_contract_id() { return Err(anyhow!( "worker launch output_contract_id must match the typed launch document" )); } validate_launch_organ_contract( &options.organ_launch_contract, &options.authority_scope, options.launch_document.document_kind(), &options.output_contract_id, )?; validate_non_empty(&options.created_at, "created at")?; let store_path = store_path.as_ref(); let job_id = options.job_id.clone(); let binding_id = options.binding_id.clone(); let role = options.role.clone(); let authority_scope = options.authority_scope.clone(); let instruction = options.instruction.clone(); let output_contract_id = options.output_contract_id.clone(); let organ_launch_contract = options.organ_launch_contract.clone(); let launch_document = options.launch_document.clone(); initialize_runtime_spine( store_path, RuntimeSpineInitOptions { runtime_id: options.runtime_id, display_name: options.display_name, created_at: options.created_at.clone(), }, )?; ensure_runtime_session( store_path, RuntimeSpineSessionOptions { session_id: options.session_id.clone(), objective: options.objective, created_at: options.created_at.clone(), coordinator_note: options.coordinator_note, }, )?; let job = create_runtime_job( store_path, RuntimeSpineJobOptions { job_id: options.job_id, session_id: options.session_id, role: options.role, created_at: options.created_at, summary: format!( "Heartbeat activation queued for binding {} with authority {}.", options.binding_id, options.authority_scope ), artifact_refs: Vec::new(), }, )?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; if cache .get::(&job_id)? .is_some() { return Err(anyhow!( "runtime worker launch request {:?} already exists", job_id )); } let request = EpiphanyRuntimeWorkerLaunchRequest { schema_version: RUNTIME_WORKER_LAUNCH_REQUEST_SCHEMA_VERSION.to_string(), job_id: job_id.clone(), binding_id, role, authority_scope, instruction, output_contract_id, document_kind: worker_launch_document_kind(&launch_document).to_string(), launch_document_msgpack: encode_worker_launch_document(&launch_document)?, metadata: BTreeMap::new(), organ_launch_contract, proposal_modeling_request_id: options.proposal_modeling_request_id, claim_repair_request_id: options.claim_repair_request_id, frontier_planning_request_id: options.frontier_planning_request_id, frontier_plan_mind_request_id: options.frontier_plan_mind_request_id, imagination_consideration_request_id: options.imagination_consideration_request_id, admitted_model_direction_consideration_request_id: options .admitted_model_direction_consideration_request_id, }; cache.put(&job_id, &request)?; Ok(job) } pub fn prepare_runtime_spine_heartbeat_job( cache: &CultCache, options: RuntimeSpineHeartbeatJobOptions, ) -> Result { validate_non_empty(&options.runtime_id, "runtime id")?; validate_non_empty(&options.display_name, "display name")?; validate_non_empty(&options.session_id, "session id")?; validate_non_empty(&options.objective, "objective")?; validate_non_empty(&options.job_id, "job id")?; validate_non_empty(&options.role, "role")?; validate_repository_body_launch_carrier(&options.role, &options.launch_document)?; validate_proposal_modeling_launch_carrier( &options.role, &options.binding_id, options.proposal_modeling_request_id.as_deref(), &options.launch_document, )?; validate_claim_repair_launch_carrier( &options.role, &options.binding_id, options.claim_repair_request_id.as_deref(), &options.launch_document, )?; validate_frontier_planning_launch_carrier( &options.role, &options.binding_id, options.frontier_planning_request_id.as_deref(), &options.launch_document, )?; validate_imagination_consideration_launch_carrier( &options.role, &options.binding_id, options.imagination_consideration_request_id.as_deref(), &options.launch_document, )?; validate_non_empty(&options.binding_id, "binding id")?; validate_non_empty(&options.authority_scope, "authority scope")?; validate_non_empty(&options.instruction, "instruction")?; validate_non_empty( options.launch_document.thread_id(), "worker launch document thread id", )?; validate_non_empty(&options.output_contract_id, "output contract id")?; if options.output_contract_id != options.launch_document.output_contract_id() { return Err(anyhow!( "worker launch output_contract_id must match the typed launch document" )); } validate_launch_organ_contract( &options.organ_launch_contract, &options.authority_scope, options.launch_document.document_kind(), &options.output_contract_id, )?; validate_non_empty(&options.created_at, "created at")?; let existing_identity = cache.get::(RUNTIME_IDENTITY_KEY)?; let identity = EpiphanyRuntimeIdentity { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), runtime_id: options.runtime_id, display_name: options.display_name, runtime_kind: "epiphany.native".to_string(), created_at: existing_identity .as_ref() .map(|value| value.created_at.clone()) .unwrap_or_else(|| options.created_at.clone()), updated_at: options.created_at.clone(), supported_document_types: runtime_registered_document_types(), metadata: BTreeMap::from([("codexEvacuationBridge".to_string(), "temporary".to_string())]), }; let session = match cache.get::(&options.session_id)? { Some(existing) if matches!( existing.status, EpiphanyRuntimeSessionStatus::Completed | EpiphanyRuntimeSessionStatus::Archived ) => { return Err(anyhow!( "runtime session {:?} is terminal and cannot accept jobs", options.session_id )); } Some(existing) => existing, None => EpiphanyRuntimeSession { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), session_id: options.session_id.clone(), objective: options.objective, status: EpiphanyRuntimeSessionStatus::Active, created_at: options.created_at.clone(), updated_at: options.created_at.clone(), coordinator_note: options.coordinator_note, metadata: BTreeMap::new(), }, }; if cache.get::(&options.job_id)?.is_some() { return Err(anyhow!("runtime job {:?} already exists", options.job_id)); } if cache .get::(&options.job_id)? .is_some() { return Err(anyhow!( "runtime worker launch request {:?} already exists", options.job_id )); } let job = EpiphanyRuntimeJob { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), job_id: options.job_id.clone(), session_id: options.session_id.clone(), role: options.role.clone(), status: EpiphanyRuntimeJobStatus::Queued, created_at: options.created_at.clone(), updated_at: options.created_at.clone(), summary: format!( "Heartbeat activation queued for binding {} with authority {}.", options.binding_id, options.authority_scope ), artifact_refs: Vec::new(), metadata: BTreeMap::new(), }; let event = EpiphanyRuntimeEvent { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), event_id: format!("event-job-opened-{}", options.job_id), occurred_at: options.created_at, event_type: "job.opened".to_string(), source: "runtime-spine".to_string(), session_id: Some(options.session_id), job_id: Some(options.job_id.clone()), summary: "Native runtime job opened.".to_string(), metadata: BTreeMap::new(), }; let request = EpiphanyRuntimeWorkerLaunchRequest { schema_version: RUNTIME_WORKER_LAUNCH_REQUEST_SCHEMA_VERSION.to_string(), job_id: options.job_id.clone(), binding_id: options.binding_id, role: options.role, authority_scope: options.authority_scope, instruction: options.instruction, output_contract_id: options.output_contract_id, document_kind: worker_launch_document_kind(&options.launch_document).to_string(), launch_document_msgpack: encode_worker_launch_document(&options.launch_document)?, metadata: BTreeMap::new(), organ_launch_contract: options.organ_launch_contract, proposal_modeling_request_id: options.proposal_modeling_request_id, claim_repair_request_id: options.claim_repair_request_id, frontier_planning_request_id: options.frontier_planning_request_id, frontier_plan_mind_request_id: options.frontier_plan_mind_request_id, imagination_consideration_request_id: options.imagination_consideration_request_id, admitted_model_direction_consideration_request_id: options .admitted_model_direction_consideration_request_id, }; let envelopes = vec![ cache.prepare_entry(RUNTIME_IDENTITY_KEY, &identity)?.0, cache.prepare_entry(&session.session_id, &session)?.0, cache.prepare_entry(&job.job_id, &job)?.0, cache.prepare_entry(&event.event_id, &event)?.0, cache.prepare_entry(&request.job_id, &request)?.0, ]; Ok(PreparedRuntimeSpineHeartbeatJob { job, envelopes }) } fn validate_proposal_modeling_launch_carrier( role: &str, binding_id: &str, proposal_modeling_request_id: Option<&str>, launch_document: &EpiphanyWorkerLaunchDocument, ) -> Result<()> { let projection = match launch_document { EpiphanyWorkerLaunchDocument::Role(document) => document.proposal_modeling_context.as_ref(), EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let Some(request_id) = proposal_modeling_request_id else { if projection.is_some() { return Err(anyhow!( "proposal Modeling context requires its typed request id" )); } return Ok(()); }; validate_non_empty(request_id, "proposal Modeling request id")?; if role != EPIPHANY_MODELING_OWNER_ROLE || binding_id != EPIPHANY_MODELING_ROLE_BINDING_ID { return Err(anyhow!( "proposal Modeling request id may only be transported by the Modeling role launch" )); } let projection = projection.ok_or_else(|| { anyhow!("proposal Modeling request id requires coordinator-owned typed context") })?; if projection.request_id != request_id { return Err(anyhow!("proposal Modeling context/request mismatch")); } Ok(()) } fn validate_repository_body_launch_carrier( role: &str, launch_document: &EpiphanyWorkerLaunchDocument, ) -> Result<()> { let (document_role, basis) = match launch_document { EpiphanyWorkerLaunchDocument::Role(document) => ( Some(document.role_id.as_str()), document.repository_body_observation_basis.as_ref(), ), EpiphanyWorkerLaunchDocument::Reorient(_) => (None, None), }; let owner_is_modeling = role == EPIPHANY_MODELING_OWNER_ROLE; let document_is_modeling = document_role.is_some_and(|value| value == "modeling"); if owner_is_modeling != document_is_modeling { return Err(anyhow!( "Modeling runtime owner and typed launch role must agree" )); } if owner_is_modeling && basis.is_none() { return Err(anyhow!( "Modeling runtime launch requires a pre-thought repository Body basis" )); } if !owner_is_modeling && basis.is_some() { return Err(anyhow!( "non-Modeling runtime launch cannot carry a repository Body basis" )); } Ok(()) } fn validate_claim_repair_launch_carrier( role: &str, binding_id: &str, claim_repair_request_id: Option<&str>, launch_document: &EpiphanyWorkerLaunchDocument, ) -> Result<()> { let projection = match launch_document { EpiphanyWorkerLaunchDocument::Role(document) => document.claim_repair_context.as_ref(), EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let Some(request_id) = claim_repair_request_id else { if projection.is_some() { return Err(anyhow!( "claim repair context requires its typed request id" )); } return Ok(()); }; validate_non_empty(request_id, "claim repair request id")?; if role != EPIPHANY_MODELING_OWNER_ROLE || binding_id != EPIPHANY_MODELING_ROLE_BINDING_ID { return Err(anyhow!( "claim repair request id may only be transported by the Modeling role launch" )); } let projection = projection.ok_or_else(|| { anyhow!("claim repair request id requires coordinator-owned typed context") })?; if projection.request_id != request_id { return Err(anyhow!("claim repair context/request mismatch")); } Ok(()) } fn validate_frontier_planning_launch_carrier( role: &str, binding_id: &str, planning_request_id: Option<&str>, launch_document: &EpiphanyWorkerLaunchDocument, ) -> Result<()> { let projection = match launch_document { EpiphanyWorkerLaunchDocument::Role(document) => document.frontier_planning_context.as_ref(), EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let Some(request_id) = planning_request_id else { if projection.is_some() { return Err(anyhow!( "frontier planning context requires its typed request id" )); } return Ok(()); }; validate_non_empty(request_id, "frontier planning request id")?; if role != EPIPHANY_IMAGINATION_OWNER_ROLE || binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID { return Err(anyhow!( "frontier planning request may only be transported by the Imagination role launch" )); } let projection = projection .ok_or_else(|| anyhow!("frontier planning request requires its typed context"))?; if projection.request_id != request_id { return Err(anyhow!("frontier planning context/request mismatch")); } Ok(()) } fn validate_imagination_consideration_launch_carrier( role: &str, binding_id: &str, request_id: Option<&str>, launch_document: &EpiphanyWorkerLaunchDocument, ) -> Result<()> { let projection = match launch_document { EpiphanyWorkerLaunchDocument::Role(document) => { document.imagination_consideration_context.as_ref() } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let Some(request_id) = request_id else { if projection.is_some() { return Err(anyhow!( "consideration context requires its typed request id" )); } return Ok(()); }; validate_non_empty(request_id, "imagination consideration request id")?; if role != EPIPHANY_IMAGINATION_OWNER_ROLE || binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID { return Err(anyhow!( "consideration may only be transported by Imagination" )); } if projection.map(|p| p.request.request_id.as_str()) != Some(request_id) { return Err(anyhow!("consideration context/request mismatch")); } Ok(()) } pub fn runtime_job_snapshot( store_path: impl AsRef, job_id: &str, ) -> Result> { validate_non_empty(job_id, "job id")?; let store_path = store_path.as_ref(); if !store_path.exists() { return Ok(None); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let Some(job) = cache.get::(job_id)? else { return Ok(None); }; let result = cache .get_all::()? .into_iter() .filter(|result| result.job_id == job_id) .max_by(|left, right| { left.completed_at .cmp(&right.completed_at) .then_with(|| left.result_id.cmp(&right.result_id)) }); Ok(Some(EpiphanyRuntimeJobSnapshot { job, result })) } pub fn runtime_worker_launch_request( store_path: impl AsRef, job_id: &str, ) -> Result> { validate_non_empty(job_id, "worker launch request job id")?; let store_path = store_path.as_ref(); if !store_path.exists() { return Ok(None); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(job_id) } pub fn runtime_worker_launch_body_basis( store_path: impl AsRef, job_id: &str, ) -> Result> { runtime_worker_launch_request(store_path, job_id)? .ok_or_else(|| anyhow!("worker launch request {job_id:?} is missing"))? .repository_body_observation_basis() } pub fn put_runtime_role_worker_result( store_path: impl AsRef, result: &EpiphanyRuntimeRoleWorkerResult, ) -> Result<()> { let store_path = store_path.as_ref(); validate_non_empty(&result.job_id, "role worker result job id")?; validate_non_empty(&result.result_id, "role worker result id")?; validate_non_empty(&result.role_id, "role worker result role id")?; if result.schema_version != RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION { return Err(anyhow!("role worker result schema version mismatch")); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let worker_launch = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("role worker result requires its immutable worker launch"))?; let launch_document = worker_launch.launch_document()?; let launch_body_basis = match &launch_document { EpiphanyWorkerLaunchDocument::Role(document) => { document.repository_body_observation_basis.as_ref() } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let launch_is_modeling = worker_launch.role == EPIPHANY_MODELING_OWNER_ROLE; let result_is_modeling = result.role_id.eq_ignore_ascii_case("modeling"); if launch_is_modeling != result_is_modeling { return Err(anyhow!( "role worker result cannot substitute Modeling launch authority" )); } if launch_is_modeling { let expected = launch_body_basis.ok_or_else(|| { anyhow!("Modeling worker launch is missing its repository Body observation basis") })?; if result.repository_body_observation_basis.as_ref() != Some(expected) { return Err(anyhow!( "Modeling result must exactly echo its immutable launch repository Body observation basis" )); } } else if launch_body_basis.is_some() || result.repository_body_observation_basis.is_some() { return Err(anyhow!( "non-Modeling worker launch and result must not carry a repository Body observation basis" )); } let is_verification = result.role_id == "verification"; if is_verification != (result .verification_request_id .as_ref() .is_some_and(|id| !id.trim().is_empty()) && result .frontier_route_id .as_ref() .is_some_and(|id| !id.trim().is_empty())) { return Err(anyhow!( "Verification results require verificationRequestId and frontierRouteId; other roles must not claim them" )); } if result.repo_frontier_modeling_request_id.is_some() && !result.role_id.eq_ignore_ascii_case("modeling") { return Err(anyhow!( "only Modeling results may echo a frontier Modeling request" )); } if result.proposal_modeling_request_id.is_some() && !result.role_id.eq_ignore_ascii_case("modeling") { return Err(anyhow!( "only Modeling results may echo a proposal Modeling request" )); } if result.claim_repair_request_id.is_some() && !result.role_id.eq_ignore_ascii_case("modeling") { return Err(anyhow!( "only Modeling results may echo a claim repair request" )); } let is_modeling = result.role_id.eq_ignore_ascii_case("modeling"); let modeling_echo_count = [ result.repo_frontier_modeling_request_id.is_some(), result.proposal_modeling_request_id.is_some(), result.claim_repair_request_id.is_some(), ] .into_iter() .filter(|present| *present) .count(); if is_modeling && modeling_echo_count > 1 { return Err(anyhow!( "Modeling result authority echoes are mutually exclusive" )); } if is_modeling && (result.verification_request_id.is_some() || result.frontier_route_id.is_some()) { return Err(anyhow!( "Modeling result cannot claim Verification route authority" )); } if is_modeling && (modeling_echo_count == 1 || result.repo_model_patch_msgpack.is_some()) { let patch_bytes = result .repo_model_patch_msgpack .as_deref() .ok_or_else(|| anyhow!("Modeling authority echo requires repoModelPatch"))?; let patch: crate::RepoModelPatch = rmp_serde::from_slice(patch_bytes) .context("decode Modeling authority echo repoModelPatch")?; match patch.purpose { crate::RepoModelPatchPurpose::Evolution if result.repo_frontier_modeling_request_id.is_some() || result.claim_repair_request_id.is_some() => { return Err(anyhow!( "Evolution result may only echo a proposal Modeling request" )); } crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { .. } if result.proposal_modeling_request_id.is_some() || result.claim_repair_request_id.is_some() || result.repo_frontier_modeling_request_id.is_none() => { return Err(anyhow!( "verdict incorporation requires only its frontier Modeling request echo" )); } crate::RepoModelPatchPurpose::RepairClaim if result.claim_repair_request_id.is_none() || result.repo_frontier_modeling_request_id.is_some() || result.proposal_modeling_request_id.is_some() || result.state_patch_msgpack.is_some() || result.self_patch_msgpack.is_some() => { return Err(anyhow!( "claim repair requires only its claim repair request echo" )); } crate::RepoModelPatchPurpose::RepairClaim => {} _ => {} } } let has_planning_echo = result.frontier_planning_request_id.is_some(); let has_planning_candidate = result.frontier_plan_candidate_msgpack.is_some(); if has_planning_echo != has_planning_candidate { return Err(anyhow!( "frontier planning result requires both its request echo and typed candidate" )); } if has_planning_echo { if !result.role_id.eq_ignore_ascii_case("imagination") { return Err(anyhow!( "only Imagination results may echo a frontier planning request" )); } if result.item_error.is_some() { return Err(anyhow!( "frontier planning result with an item error cannot carry an executable candidate" )); } if result.state_patch_msgpack.is_some() || result.self_patch_msgpack.is_some() || result.repo_model_patch_msgpack.is_some() || result.verification_request_id.is_some() || result.frontier_route_id.is_some() || result.repo_frontier_modeling_request_id.is_some() || result.proposal_modeling_request_id.is_some() || result.claim_repair_request_id.is_some() { return Err(anyhow!( "frontier planning result may carry only its request echo and typed candidate authority" )); } let request_id = result .frontier_planning_request_id .as_deref() .ok_or_else(|| anyhow!("frontier planning request echo disappeared"))?; let request = cache .get::(request_id)? .ok_or_else(|| anyhow!("frontier planning result requires persisted request"))?; validate_current_repo_frontier_planning_request(&cache, &request)?; let candidate = result .frontier_plan_candidate()? .ok_or_else(|| anyhow!("frontier planning candidate disappeared"))?; validate_repo_frontier_plan_candidate_against_request(&cache, &candidate, &request)?; let bindings = cache .get_all::()? .into_iter() .filter(|binding| { binding.planning_request_id == request.request_id && binding.job_id == result.job_id }) .collect::>(); if bindings.len() != 1 { return Err(anyhow!( "frontier planning result requires exactly one coordinator launch binding" )); } let binding = &bindings[0]; let worker_launch = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("frontier planning result requires its worker launch"))?; let launch_document = worker_launch.launch_document()?; let projection = match &launch_document { EpiphanyWorkerLaunchDocument::Role(document) => { document.frontier_planning_context.as_ref() } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let expected_projection = crate::RepoFrontierPlanningContextProjection::from_request(&request); let launch_hash = format!( "{:x}", Sha256::digest(&worker_launch.launch_document_msgpack) ); let expected_binding_record_id = if binding.attempt_ordinal == 0 { format!("repo-frontier-planning-launch-{}", request.request_id) } else { format!( "repo-frontier-planning-launch-{}-attempt-{}", request.request_id, binding.attempt_ordinal ) }; if binding.schema_version != REPO_FRONTIER_PLANNING_LAUNCH_BINDING_SCHEMA_VERSION || binding.contract != REPO_FRONTIER_PLANNING_LAUNCH_BINDING_CONTRACT || binding.binding_record_id != expected_binding_record_id || binding.job_id != result.job_id || binding.binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID || binding.runtime_id != request.runtime_id || binding.thread_id != request.thread_id || binding.worker_launch_document_sha256 != launch_hash || worker_launch.job_id != result.job_id || worker_launch.role != EPIPHANY_IMAGINATION_OWNER_ROLE || worker_launch.binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID || worker_launch.frontier_planning_request_id.as_deref() != Some(request.request_id.as_str()) || worker_launch.proposal_modeling_request_id.is_some() || worker_launch.claim_repair_request_id.is_some() || projection != Some(&expected_projection) { return Err(anyhow!( "frontier planning result does not exactly bind request, launch, runtime, thread, and candidate" )); } } let mut model_direction_companion = None; let has_model_direction_echo = result .admitted_model_direction_consideration_request_id .is_some(); let has_model_direction_result = result .admitted_model_direction_consideration_result_msgpack .is_some(); if has_model_direction_echo != has_model_direction_result { return Err(anyhow!( "model direction result requires exact request echo and result" )); } if has_model_direction_echo { if !result.role_id.eq_ignore_ascii_case("imagination") || result.item_error.is_some() || result.state_patch_msgpack.is_some() || result.self_patch_msgpack.is_some() || result.repo_model_patch_msgpack.is_some() || result.imagination_consideration_request_id.is_some() || result.imagination_consideration_candidate_msgpack.is_some() { return Err(anyhow!( "model direction result carries foreign authority cargo" )); } let request_id = result .admitted_model_direction_consideration_request_id .as_deref() .unwrap(); let request = cache .get::(request_id)? .ok_or_else(|| anyhow!("model direction result request disappeared"))?; crate::validate_current_admitted_model_direction_consideration_request(&cache, &request)?; let direction_result = result .admitted_model_direction_consideration_result()? .ok_or_else(|| anyhow!("model direction result disappeared"))?; crate::validate_admitted_model_direction_consideration_result(&request, &direction_result)?; if direction_result.result_id != crate::admitted_model_direction_consideration_result_id_for_launch( request_id, &result.job_id, ) { return Err(anyhow!( "model direction result identity was not assigned by exact launch" )); } let worker = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("model direction result requires worker launch"))?; let document = worker.launch_document()?; let projection = match &document { EpiphanyWorkerLaunchDocument::Role(document) => document .admitted_model_direction_consideration_context .as_ref(), EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; if worker.role != EPIPHANY_IMAGINATION_OWNER_ROLE || worker.binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID || worker .admitted_model_direction_consideration_request_id .as_deref() != Some(request_id) || projection.map(|projection| &projection.request) != Some(&request) { return Err(anyhow!( "model direction result does not exactly bind request and launch" )); } model_direction_companion = Some(direction_result); } let has_consideration_echo = result.imagination_consideration_request_id.is_some(); let has_consideration_candidate = result.imagination_consideration_candidate_msgpack.is_some(); if has_consideration_echo != has_consideration_candidate { return Err(anyhow!( "consideration result requires request echo and candidate" )); } if has_consideration_echo { if !result.role_id.eq_ignore_ascii_case("imagination") || result.item_error.is_some() || result.state_patch_msgpack.is_some() || result.self_patch_msgpack.is_some() || result.repo_model_patch_msgpack.is_some() || result.verification_request_id.is_some() || result.frontier_route_id.is_some() || result.repo_frontier_modeling_request_id.is_some() || result.proposal_modeling_request_id.is_some() || result.claim_repair_request_id.is_some() || result.frontier_planning_request_id.is_some() || result.frontier_plan_candidate_msgpack.is_some() || result.frontier_plan_mind_request_id.is_some() || result.frontier_plan_mind_decision_msgpack.is_some() { return Err(anyhow!( "consideration result carries foreign authority cargo" )); } let request_id = result .imagination_consideration_request_id .as_deref() .unwrap(); let request = cache .get::(request_id)? .ok_or_else(|| anyhow!("consideration result request disappeared"))?; crate::validate_current_imagination_consideration_request(&cache, &request)?; let candidate = result .imagination_consideration_candidate()? .ok_or_else(|| anyhow!("consideration candidate disappeared"))?; crate::validate_imagination_consideration_candidate(&request, &candidate)?; if candidate.candidate_id != crate::imagination_consideration_candidate_id_for_launch(request_id, &result.job_id) { return Err(anyhow!( "consideration candidate identity was not assigned by exact launch" )); } let bindings = cache .get_all::()? .into_iter() .filter(|binding| binding.request_id == request_id) .collect::>(); if bindings.len() != 1 { return Err(anyhow!("consideration result requires one launch binding")); } let binding = &bindings[0]; let worker = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("consideration result requires worker launch"))?; let document = worker.launch_document()?; let projection = match &document { EpiphanyWorkerLaunchDocument::Role(document) => { document.imagination_consideration_context.as_ref() } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let launch_hash = format!("{:x}", Sha256::digest(&worker.launch_document_msgpack)); if binding.job_id != result.job_id || binding.binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID || binding.runtime_id != request.runtime_id || binding.thread_id != request.thread_id || binding.worker_launch_document_sha256 != launch_hash || worker.role != EPIPHANY_IMAGINATION_OWNER_ROLE || worker.binding_id != EPIPHANY_IMAGINATION_ROLE_BINDING_ID || worker.imagination_consideration_request_id.as_deref() != Some(request_id) || projection.map(|projection| &projection.request) != Some(&request) || projection .map(|projection| crate::memory_graph_model_hash(&projection.model)) .transpose()? != Some(request.model_hash.clone()) { return Err(anyhow!( "consideration result substituted request, launch, or context" )); } } let has_mind_echo = result.frontier_plan_mind_request_id.is_some(); let has_mind_decision = result.frontier_plan_mind_decision_msgpack.is_some(); if has_mind_echo != has_mind_decision { return Err(anyhow!( "Mind result requires both exact request echo and typed decision" )); } if has_mind_echo { if !result.role_id.eq_ignore_ascii_case("mindAdmissionReview") || result.item_error.is_some() || result.state_patch_msgpack.is_some() || result.self_patch_msgpack.is_some() || result.repo_model_patch_msgpack.is_some() || result.frontier_planning_request_id.is_some() || result.frontier_plan_candidate_msgpack.is_some() || result.verification_request_id.is_some() || result.frontier_route_id.is_some() || result.repo_frontier_modeling_request_id.is_some() || result.proposal_modeling_request_id.is_some() || result.claim_repair_request_id.is_some() { return Err(anyhow!( "Mind decision result carries foreign authority cargo" )); } let request_id = result.frontier_plan_mind_request_id.as_deref().unwrap(); let request = cache .get::(request_id)? .ok_or_else(|| anyhow!("Mind result request disappeared"))?; let (planning, candidate) = validate_repo_frontier_plan_mind_request(&cache, &request)?; let decision = result .frontier_plan_mind_decision()? .ok_or_else(|| anyhow!("Mind decision disappeared"))?; if decision.mind_request_id != request.request_id || decision.planning_request_id != planning.request_id || decision.imagination_result_id != request.imagination_result_id || decision.candidate_id != candidate.candidate_id || decision.candidate_sha256 != request.candidate_sha256 || decision.rationale.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&decision.decided_at).is_err() { return Err(anyhow!( "Mind decision substituted request echo or immutable candidate identity" )); } let bindings = cache .get_all::()? .into_iter() .filter(|binding| { binding.mind_request_id == request.request_id && binding.job_id == result.job_id }) .collect::>(); if bindings.len() != 1 { return Err(anyhow!( "Mind result requires exactly one coordinator launch binding" )); } let binding = &bindings[0]; let launch = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("Mind result launch disappeared"))?; let document = launch.launch_document()?; let projection = match &document { EpiphanyWorkerLaunchDocument::Role(d) => d.frontier_plan_mind_context.as_ref(), _ => None, }; let expected = RepoFrontierPlanMindContextProjection::new(&request, &planning, &candidate); let hash = format!("{:x}", Sha256::digest(&launch.launch_document_msgpack)); if binding.schema_version != REPO_FRONTIER_PLAN_MIND_LAUNCH_BINDING_SCHEMA_VERSION || binding.contract != REPO_FRONTIER_PLAN_MIND_LAUNCH_BINDING_CONTRACT || binding.job_id != result.job_id || binding.binding_id != EPIPHANY_MIND_ROLE_BINDING_ID || binding.runtime_id != request.runtime_id || binding.thread_id != request.thread_id || binding.worker_launch_document_sha256 != hash || launch.role != EPIPHANY_MIND_OWNER_ROLE || launch.binding_id != EPIPHANY_MIND_ROLE_BINDING_ID || launch.frontier_plan_mind_request_id.as_deref() != Some(request.request_id.as_str()) || projection != Some(&expected) { return Err(anyhow!( "Mind result does not exactly bind request, launch, runtime, thread, and candidate" )); } } if let Some(existing) = cache.get::(&result.job_id)? { if existing != *result { return Err(anyhow!( "role worker result is immutable for its runtime job" )); } if let Some(companion) = model_direction_companion.as_ref() { return match cache .get::(&companion.result_id)? { Some(existing) if existing == *companion => Ok(()), _ => Err(anyhow!( "model direction worker result lost its exact typed companion" )), }; } return Ok(()); } let (envelope, _) = cache.prepare_entry(&result.job_id, result)?; let mut writes = vec![envelope]; if let Some(companion) = model_direction_companion.as_ref() { if cache .get::(&companion.result_id)? .is_some() { return Err(anyhow!( "model direction result companion identity already exists without its worker result" )); } let (companion_envelope, _) = cache.prepare_entry(&companion.result_id, companion)?; writes.push(companion_envelope); } let backing = SingleFileMessagePackBackingStore::new(store_path); if backing.compare_and_swap_batch(&[], writes)? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; let worker_matches = reloaded .get::(&result.job_id)? .is_some_and(|existing| existing == *result); let companion_matches = match model_direction_companion.as_ref() { Some(companion) => reloaded .get::(&companion.result_id)? .is_some_and(|existing| existing == *companion), None => true, }; if worker_matches && companion_matches { Ok(()) } else { Err(anyhow!( "role worker result lost immutable insertion to a different result or companion" )) } } pub fn runtime_role_worker_result( store_path: impl AsRef, job_id: &str, ) -> Result> { validate_non_empty(job_id, "role worker result job id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(job_id) } pub fn ensure_runtime_repo_model( runtime_store: impl AsRef, legacy_memory_store: impl AsRef, bootstrap_snapshot: &crate::EpiphanyMemoryGraphSnapshot, at: &str, ) -> Result<( crate::EpiphanyMemoryGraphSnapshot, RepoModelMigrationReceipt, )> { chrono::DateTime::parse_from_rfc3339(at) .map_err(|_| anyhow!("repo model migration timestamp must be RFC3339"))?; let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; if let Some(entry) = cache.get::(crate::MEMORY_GRAPH_KEY)? { crate::validate_memory_graph_entry(&entry)?; let receipt = cache .get::("repo-model-migration")? .ok_or_else(|| anyhow!("runtime repo model exists without its migration receipt"))?; let snapshot = entry.snapshot()?; require_modeling_projection_obligation_for_commit( &cache, &receipt.receipt_id, receipt.imported_revision, &receipt.imported_hash, &receipt.imported_at, )?; return Ok((snapshot, receipt)); } let (snapshot, source_store) = match crate::load_memory_graph_snapshot(legacy_memory_store.as_ref())? { Some(snapshot) => (snapshot, legacy_memory_store.as_ref().display().to_string()), None => (bootstrap_snapshot.clone(), "supplied-bootstrap".to_string()), }; let entry = crate::EpiphanyMemoryGraphEntry::from_snapshot(&snapshot)?; crate::validate_memory_graph_entry(&entry)?; let imported_hash = crate::memory_graph_model_hash(&snapshot)?; let receipt = RepoModelMigrationReceipt { schema_version: REPO_MODEL_MIGRATION_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: "repo-model-migration".to_string(), source_store, source_graph_id: snapshot.graph_id.clone(), imported_revision: snapshot.model_revision, imported_hash, imported_at: at.to_string(), contract: REPO_MODEL_MIGRATION_CONTRACT.to_string(), }; let (model_envelope, _) = cache.prepare_entry(crate::MEMORY_GRAPH_KEY, &entry)?; let (receipt_envelope, _) = cache.prepare_entry(&receipt.receipt_id, &receipt)?; let obligation = modeling_projection_obligation( &cache, &snapshot, &receipt.receipt_id, &receipt.imported_at, )?; let (obligation_envelope, _) = cache.prepare_entry(&obligation.obligation_id, &obligation)?; let backing = SingleFileMessagePackBackingStore::new(runtime_store); if backing.compare_and_swap_batch( &[], vec![model_envelope, receipt_envelope, obligation_envelope], )? { return Ok((snapshot, receipt)); } let mut reloaded = runtime_spine_cache(runtime_store)?; reloaded.pull_all_backing_stores()?; match ( reloaded.get::(crate::MEMORY_GRAPH_KEY)?, reloaded.get::("repo-model-migration")?, ) { (Some(entry), Some(existing_receipt)) => { crate::validate_memory_graph_entry(&entry)?; let snapshot = entry.snapshot()?; if existing_receipt.schema_version != REPO_MODEL_MIGRATION_RECEIPT_SCHEMA_VERSION || existing_receipt.contract != REPO_MODEL_MIGRATION_CONTRACT || existing_receipt.source_graph_id != snapshot.graph_id || existing_receipt.imported_revision != snapshot.model_revision || existing_receipt.imported_hash != crate::memory_graph_model_hash(&snapshot)? { return Err(anyhow!("runtime repo model migration companion collision")); } require_modeling_projection_obligation_for_commit( &reloaded, &existing_receipt.receipt_id, existing_receipt.imported_revision, &existing_receipt.imported_hash, &existing_receipt.imported_at, )?; Ok((snapshot, existing_receipt)) } _ => Err(anyhow!( "runtime repo model migration lost to a companion identity collision" )), } } pub fn migrate_legacy_repo_model_projection_obligation( runtime_store: impl AsRef, ) -> Result> { let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let Some(entry) = cache.get::(crate::MEMORY_GRAPH_KEY)? else { return Ok(None); }; crate::validate_memory_graph_entry(&entry)?; let snapshot = entry.snapshot()?; let receipt = cache .get::("repo-model-migration")? .ok_or_else(|| anyhow!("legacy RepoModel has no migration receipt"))?; if receipt.imported_revision != snapshot.model_revision || receipt.imported_hash != crate::memory_graph_model_hash(&snapshot)? { return Err(anyhow!( "legacy projection-obligation migration only accepts an unchanged bootstrap RepoModel" )); } let expected = modeling_projection_obligation( &cache, &snapshot, &receipt.receipt_id, &receipt.imported_at, )?; let matches = cache .get_all::()? .into_iter() .filter(|candidate| candidate.source_commit_id == receipt.receipt_id) .collect::>(); if matches.len() == 1 && matches[0] == expected { return Ok(Some(expected)); } if !matches.is_empty() { return Err(anyhow!( "legacy RepoModel projection obligation identity collision" )); } let backing = SingleFileMessagePackBackingStore::new(runtime_store); let opening = backing.pull_all()?; let preserve_types = [ (crate::MEMORY_GRAPH_TYPE, crate::MEMORY_GRAPH_KEY), ( REPO_MODEL_MIGRATION_RECEIPT_TYPE, receipt.receipt_id.as_str(), ), (RUNTIME_SWARM_BINDING_TYPE, RUNTIME_SWARM_BINDING_KEY), ]; let mut preserved = Vec::new(); for (document_type, key) in preserve_types { preserved.push( opening .iter() .find(|envelope| envelope.r#type == document_type && envelope.key == key) .cloned() .ok_or_else(|| anyhow!("legacy RepoModel migration companion disappeared"))?, ); } let obligation_envelope = cache.prepare_entry(&expected.obligation_id, &expected)?.0; let mut replacement = preserved.clone(); replacement.push(obligation_envelope); if backing.compare_and_swap_batch(&preserved, replacement)? { return Ok(Some(expected)); } let mut reloaded = runtime_spine_cache(runtime_store)?; reloaded.pull_all_backing_stores()?; require_modeling_projection_obligation_for_commit( &reloaded, &receipt.receipt_id, receipt.imported_revision, &receipt.imported_hash, &receipt.imported_at, ) .map(Some) } pub fn commit_repo_model_admission( runtime_store: impl AsRef, result_id: &str, review: &RepoModelAdmissionReview, ) -> Result { validate_non_empty(result_id, "repo model admission result id")?; validate_non_empty(&review.review_id, "repo model admission review id")?; if !crate::repo_model_admission_review_schema_supported( &review.schema_version, &review.contract, ) { return Err(anyhow!("unsupported repo model admission review contract")); } if review.decision != MindGatewayDecision::Accept { return Err(anyhow!("repo model admission requires an Accept review")); } chrono::DateTime::parse_from_rfc3339(&review.reviewed_at) .map_err(|_| anyhow!("repo model admission review timestamp must be RFC3339"))?; if review.result_id.as_deref() != Some(result_id) { return Err(anyhow!( "repo model admission review/result binding mismatch" )); } let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let matching_results = cache .get_all::()? .into_iter() .filter(|candidate| candidate.result_id == result_id) .collect::>(); if matching_results.len() != 1 { return Err(anyhow!( "repo model admission requires one immutable Modeling result" )); } let result = matching_results.into_iter().next().expect("one result"); if !result.role_id.eq_ignore_ascii_case("modeling") || review.job_id.as_deref() != Some(result.job_id.as_str()) || review.result_id.as_deref() != Some(result.result_id.as_str()) || result.schema_version != RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION || result.item_error.is_some() { return Err(anyhow!( "repo model admission result role/job binding mismatch" )); } let expected_admission_source = if review.schema_version == crate::LEGACY_REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION { None } else { Some(crate::RepoModelAdmissionSource::WorkerResult { result_id: result.result_id.clone(), job_id: result.job_id.clone(), }) }; if review.admission_source != expected_admission_source { return Err(anyhow!("repo model admission review provenance mismatch")); } let worker_launch = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("repo model admission requires the immutable Modeling launch"))?; let launch_document = worker_launch.launch_document()?; let launch_basis = match &launch_document { EpiphanyWorkerLaunchDocument::Role(document) => document .repository_body_observation_basis .as_ref() .ok_or_else(|| { anyhow!("repo model admission launch has no repository Body observation basis") })?, EpiphanyWorkerLaunchDocument::Reorient(_) => { return Err(anyhow!( "repo model admission cannot originate from reorientation" )); } }; let result_basis = result .repository_body_observation_basis .as_ref() .ok_or_else(|| { anyhow!("repo model admission result has no repository Body observation basis") })?; let review_basis = review .repository_body_observation_basis .as_ref() .ok_or_else(|| { anyhow!("repo model admission review has no repository Body observation basis") })?; if worker_launch.role != EPIPHANY_MODELING_OWNER_ROLE || launch_basis != result_basis || launch_basis != review_basis { return Err(anyhow!( "repo model admission requires one exact launch/result/review repository Body observation basis" )); } crate::validate_repository_body_observation_basis(runtime_store, launch_basis)?; let patch_bytes = result .repo_model_patch_msgpack .as_deref() .ok_or_else(|| anyhow!("Modeling result is missing repoModelPatch"))?; let patch: crate::RepoModelPatch = rmp_serde::from_slice(patch_bytes) .context("decode exact Modeling result repoModelPatch")?; let patch_sha256 = format!("{:x}", Sha256::digest(patch_bytes)); if review.patch_id != patch.patch_id || review.patch_sha256 != patch_sha256 || review.base_revision != patch.base_revision || review.base_hash != patch.base_hash { return Err(anyhow!( "repo model admission review/patch binding mismatch" )); } let mut result_evidence = result.evidence_ids.clone(); let mut review_evidence = review.evidence_ids.clone(); result_evidence.sort(); result_evidence.dedup(); review_evidence.sort(); review_evidence.dedup(); if review_evidence.is_empty() || review_evidence != result_evidence { return Err(anyhow!( "repo model admission review evidence does not exactly bind the Modeling result" )); } let receipt_id = format!("repo-model-admission-{}", review.review_id); if patch.purpose == crate::RepoModelPatchPurpose::RepairClaim { match ( cache.get::(&review.review_id)?, cache.get::(&receipt_id)?, ) { (Some(existing_review), Some(existing_receipt)) if existing_review == *review => { let repair_request_id = result .claim_repair_request_id .as_deref() .ok_or_else(|| anyhow!("RepairClaim retry is missing its request echo"))?; let repair_request = cache .get::(repair_request_id)? .ok_or_else(|| anyhow!("RepairClaim retry request disappeared"))?; let current_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("RepairClaim retry requires canonical RepoModel"))?; let current_model = current_entry.snapshot()?; let current_hash = crate::memory_graph_model_hash(¤t_model)?; if existing_receipt.receipt_id != receipt_id || existing_receipt.review_id != review.review_id || existing_receipt.result_id.as_deref() != Some(result_id) || existing_receipt.patch_id != patch.patch_id || existing_receipt.patch_sha256 != patch_sha256 || !crate::repo_model_admission_receipt_schema_supported( &existing_receipt.schema_version, &existing_receipt.contract, ) || existing_receipt.purpose != patch.purpose || existing_receipt.admission_source != expected_admission_source || existing_receipt.claim_repair_request_id != repair_request_id || !existing_receipt.frontier_plan_decision_id.is_empty() || existing_receipt.previous_revision != repair_request.model_revision || existing_receipt.previous_hash != repair_request.model_hash || existing_receipt.admitted_revision != current_model.model_revision || existing_receipt.admitted_revision != existing_receipt.previous_revision.saturating_add(1) || existing_receipt.admitted_hash != current_hash || existing_receipt.admitted_at != review.reviewed_at || !existing_receipt.frontier_route_id.is_empty() || !existing_receipt.verification_request_id.is_empty() || !existing_receipt.soul_verdict_receipt_id.is_empty() || !existing_receipt.frontier_modeling_request_id.is_empty() || !existing_receipt.proposal_modeling_request_id.is_empty() || existing_receipt.repository_body_observation_basis != review.repository_body_observation_basis { return Err(anyhow!("repo model admission receipt identity collision")); } return Ok(existing_receipt); } (None, None) => {} _ => return Err(anyhow!("repo model admission companion identity collision")), } } let ( frontier_route_id, verification_request_id, soul_verdict_receipt_id, frontier_modeling_request_id, proposal_modeling_request_id, claim_repair_request_id, ) = match &patch.purpose { crate::RepoModelPatchPurpose::AdoptFrontierPlan { .. } => { return Err(anyhow!( "frontier plan adoption is Mind-owned and cannot enter through generic repo model admission" )); } crate::RepoModelPatchPurpose::RelinquishFrontierRoute { .. } => { return Err(anyhow!( "frontier route relinquishment is a Mind-owned transaction and cannot enter through generic repo model admission" )); } crate::RepoModelPatchPurpose::RepairClaim => { if result.repo_frontier_modeling_request_id.is_some() || result.proposal_modeling_request_id.is_some() || result.verification_request_id.is_some() || result.frontier_route_id.is_some() || result.state_patch_msgpack.is_some() || result.self_patch_msgpack.is_some() { return Err(anyhow!( "claim repair result may carry only its repair request echo" )); } let request_id = result .claim_repair_request_id .as_deref() .ok_or_else(|| anyhow!("RepairClaim requires its exact repair request echo"))?; let request = cache .get::(request_id)? .ok_or_else(|| anyhow!("RepairClaim requires its persisted repair request"))?; validate_current_repo_model_claim_repair_request(&cache, &request)?; let challenge = cache .get::(&request.challenge_id)? .ok_or_else(|| anyhow!("RepairClaim requires its exact challenge"))?; let bindings = cache .get_all::()? .into_iter() .filter(|binding| binding.repair_request_id == request.request_id) .collect::>(); if bindings.len() != 1 { return Err(anyhow!( "RepairClaim requires exactly one coordinator launch binding" )); } let binding = &bindings[0]; let worker_launch = cache .get::(&result.job_id)? .ok_or_else(|| anyhow!("RepairClaim requires its runtime worker launch"))?; let launch_document = worker_launch.launch_document()?; let launch_projection = match &launch_document { EpiphanyWorkerLaunchDocument::Role(document) => { document.claim_repair_context.as_ref() } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let identity = require_identity(&cache)?; let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("RepairClaim requires authoritative thread state"))?; let expected_projection = crate::RepoModelClaimRepairContextProjection::from_request(&request); let launch_hash = format!( "{:x}", Sha256::digest(&worker_launch.launch_document_msgpack) ); chrono::DateTime::parse_from_rfc3339(&binding.launched_at) .map_err(|_| anyhow!("RepairClaim launch binding timestamp must be RFC3339"))?; if binding.schema_version != crate::REPO_MODEL_CLAIM_REPAIR_LAUNCH_BINDING_SCHEMA_VERSION || binding.contract != crate::REPO_MODEL_CLAIM_REPAIR_LAUNCH_BINDING_CONTRACT || binding.repair_request_id != request.request_id || binding.challenge_id != request.challenge_id || binding.challenge_sha256 != request.challenge_sha256 || binding.job_id != result.job_id || binding.binding_id != crate::EPIPHANY_MODELING_ROLE_BINDING_ID || binding.runtime_id != request.runtime_id || binding.thread_id != request.thread_id || binding.worker_launch_document_sha256 != launch_hash || worker_launch.job_id != result.job_id || worker_launch.role != crate::EPIPHANY_MODELING_OWNER_ROLE || worker_launch.binding_id != crate::EPIPHANY_MODELING_ROLE_BINDING_ID || worker_launch.claim_repair_request_id.as_deref() != Some(request.request_id.as_str()) || worker_launch.proposal_modeling_request_id.is_some() || launch_projection != Some(&expected_projection) || identity.runtime_id != request.runtime_id || thread.thread_id != request.thread_id || patch.base_revision != request.model_revision || patch.base_hash != request.model_hash { return Err(anyhow!( "RepairClaim does not exactly bind request, launch, runtime, thread, and model" )); } if patch.operations.len() != 1 { return Err(anyhow!("RepairClaim permits exactly one node revision")); } let crate::RepoModelPatchOperation::ReviseNode { node } = &patch.operations[0] else { return Err(anyhow!("RepairClaim permits only ReviseNode")); }; if node.id != request.target_claim_id { return Err(anyhow!("RepairClaim revision targets the wrong claim")); } let current_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("RepairClaim requires canonical RepoModel"))?; let current_model = current_entry.snapshot()?; let current_node = current_model .nodes .iter() .find(|candidate| candidate.id == request.target_claim_id) .ok_or_else(|| anyhow!("RepairClaim target claim disappeared"))?; let current_node_hash = format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(current_node)?) ); let revised_node_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(node)?)); if current_node_hash != request.target_claim_sha256 || revised_node_hash == request.target_claim_sha256 || node.claim == current_node.claim || node.id != current_node.id || node.domain_id != current_node.domain_id || node.profile != current_node.profile || node.kind != current_node.kind || node.created_at != current_node.created_at || node.lifecycle != current_node.lifecycle { return Err(anyhow!( "RepairClaim must change the exact challenged claim while preserving identity anatomy" )); } let mut expected_evidence = challenge.evidence_ids.clone(); expected_evidence.push(challenge.challenge_id.clone()); expected_evidence.push(request.eyes_evidence_packet_id.clone()); expected_evidence.sort(); expected_evidence.dedup(); if result_evidence != expected_evidence { return Err(anyhow!( "RepairClaim evidence must exactly cite its challenge and Eyes evidence chain" )); } if cache .get_all::()? .iter() .any(|receipt| { receipt.claim_repair_request_id == request.request_id && (receipt.review_id != review.review_id || receipt.result_id.as_deref() != Some(result.result_id.as_str())) }) { return Err(anyhow!("claim repair request is already incorporated")); } ( String::new(), String::new(), String::new(), String::new(), String::new(), request.request_id, ) } crate::RepoModelPatchPurpose::Evolution => { if result.repo_frontier_modeling_request_id.is_some() || result.verification_request_id.is_some() || result.frontier_route_id.is_some() { return Err(anyhow!( "Evolution result cannot claim verdict-incorporation or Verification authority" )); } let echoed = result.proposal_modeling_request_id.as_deref(); let upserts = patch .operations .iter() .filter_map(|operation| match operation { crate::RepoModelPatchOperation::UpsertFrontier { item } => Some(item), _ => None, }) .collect::>(); let frontier_operation_count = patch .operations .iter() .filter(|operation| { matches!( operation, crate::RepoModelPatchOperation::UpsertFrontier { .. } | crate::RepoModelPatchOperation::ReviseFrontier { .. } | crate::RepoModelPatchOperation::RetireFrontier { .. } ) }) .count(); let request_id = if let Some(request_id) = echoed { let request = cache .get::(request_id)? .ok_or_else(|| { anyhow!("proposal Evolution requires exact selection request") })?; validate_repo_frontier_proposal_modeling_request(&request)?; let proposal = cache .get::(&request.proposal_id)? .ok_or_else(|| anyhow!("proposal Evolution requires exact proposal"))?; validate_repo_frontier_work_proposal(&proposal)?; if proposal.source_kind == crate::RepoFrontierProposalSourceKind::Imagination { validate_autonomous_proposal_binding(&cache, &proposal)?; } let launch_bindings = cache .get_all::()? .into_iter() .filter(|binding| binding.job_id == result.job_id) .collect::>(); if launch_bindings.len() != 1 { return Err(anyhow!( "proposal Evolution requires exactly one coordinator launch binding for its job" )); } let launch_binding = &launch_bindings[0]; let worker_launch = cache .get::(&result.job_id)? .ok_or_else(|| { anyhow!("proposal Evolution requires its runtime worker launch request") })?; let worker_launch_document = worker_launch.launch_document()?; let launch_projection = match &worker_launch_document { EpiphanyWorkerLaunchDocument::Role(document) => { document.proposal_modeling_context.as_ref() } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let identity = require_identity(&cache)?; let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| { anyhow!("proposal Evolution requires authoritative thread state") })?; thread.state()?; let content = rmp_serde::to_vec_named(&( &proposal.title, &proposal.body, &proposal.desired_outcome, &proposal.constraints, &proposal.scope_hints, &proposal.evidence_refs, ))?; let payload_hash = format!("{:x}", Sha256::digest(content)); let expected_projection = crate::RepoFrontierProposalModelingContextProjection { schema_version: crate::REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_SCHEMA_VERSION .into(), contract: crate::REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_CONTRACT.into(), request_id: request.request_id.clone(), proposal_id: proposal.proposal_id.clone(), proposal_payload_sha256: proposal.payload_sha256.clone(), runtime_id: request.runtime_id.clone(), thread_id: request.thread_id.clone(), repository: request.repository.clone(), workspace: request.workspace.clone(), source_kind: proposal.source_kind, source_actor: proposal.source_actor.clone(), source_ref: proposal.source_ref.clone(), title: proposal.title.clone(), body: proposal.body.clone(), desired_outcome: proposal.desired_outcome.clone(), constraints: proposal.constraints.clone(), scope_hints: proposal.scope_hints.clone(), evidence_refs: proposal.evidence_refs.clone(), private_state_included: proposal.private_state_included, model_revision: patch.base_revision, model_hash: patch.base_hash.clone(), }; let launch_document_sha256 = format!( "{:x}", Sha256::digest(&worker_launch.launch_document_msgpack) ); let mismatches = [ ( "request.schema", request.schema_version != REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION, ), ( "request.contract", request.contract != REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_CONTRACT, ), ( "proposal.schema", proposal.schema_version != REPO_FRONTIER_WORK_PROPOSAL_SCHEMA_VERSION, ), ( "proposal.contract", proposal.contract != REPO_FRONTIER_WORK_PROPOSAL_CONTRACT, ), ("proposal.private", proposal.private_state_included), ( "request.payload", request.proposal_payload_sha256 != proposal.payload_sha256, ), ("proposal.payload", proposal.payload_sha256 != payload_hash), ( "request.proposal_runtime", request.runtime_id != proposal.runtime_id, ), ("request.runtime", request.runtime_id != identity.runtime_id), ( "request.proposal_thread", request.thread_id != proposal.thread_id, ), ("request.thread", request.thread_id != thread.thread_id), ( "request.repository", request.repository != proposal.repository, ), ("request.workspace", request.workspace != proposal.workspace), ( "binding.id", launch_binding.binding_record_id != format!("repo-frontier-proposal-modeling-launch-{}", result.job_id), ), ( "binding.schema", launch_binding.schema_version != REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_SCHEMA_VERSION, ), ( "binding.contract", launch_binding.contract != REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_CONTRACT, ), ( "binding.request", launch_binding.proposal_modeling_request_id != request.request_id, ), ( "binding.proposal", launch_binding.proposal_id != proposal.proposal_id, ), ( "binding.payload", launch_binding.proposal_payload_sha256 != proposal.payload_sha256, ), ("binding.job", launch_binding.job_id != result.job_id), ( "binding.role", launch_binding.binding_id != EPIPHANY_MODELING_ROLE_BINDING_ID, ), ( "binding.runtime", launch_binding.runtime_id != identity.runtime_id, ), ( "binding.thread", launch_binding.thread_id != thread.thread_id, ), ( "binding.launched_at", chrono::DateTime::parse_from_rfc3339(&launch_binding.launched_at).is_err(), ), ( "binding.launch_document_hash", launch_binding.worker_launch_document_sha256 != launch_document_sha256, ), ( "launch.schema", worker_launch.schema_version != RUNTIME_WORKER_LAUNCH_REQUEST_SCHEMA_VERSION, ), ("launch.job", worker_launch.job_id != result.job_id), ( "launch.binding", worker_launch.binding_id != launch_binding.binding_id, ), ( "launch.role", worker_launch.role != EPIPHANY_MODELING_OWNER_ROLE, ), ( "launch.request", worker_launch.proposal_modeling_request_id.as_deref() != Some(request.request_id.as_str()), ), ( "launch.projection", launch_projection != Some(&expected_projection), ), ( "launch.model_base", expected_projection.model_revision != patch.base_revision || expected_projection.model_hash != patch.base_hash, ), ] .into_iter() .filter_map(|(name, failed)| failed.then_some(name)) .collect::>(); if !mismatches.is_empty() { return Err(anyhow!( "proposal Evolution provenance binding mismatch: {}", mismatches.join(", ") )); } if cache .get_all::()? .iter() .any(|receipt| { receipt.proposal_modeling_request_id == request.request_id && (receipt.review_id != review.review_id || receipt.result_id.as_deref() != Some(result.result_id.as_str())) }) { return Err(anyhow!("proposal Modeling request already incorporated")); } if !result_evidence.iter().any(|id| id == &proposal.proposal_id) || frontier_operation_count != 1 || upserts.len() != 1 || !upserts[0] .evidence_refs .iter() .any(|id| id == &proposal.proposal_id) { return Err(anyhow!( "proposal Evolution requires one proposal-citing frontier upsert and exact evidence" )); } if upserts[0].source_scope.is_empty() || !safe_sorted_unique_paths(&upserts[0].source_scope) { return Err(anyhow!( "proposal Evolution frontier source_scope must be non-empty, safe relative paths in strict lexicographic order with no duplicates" )); } if upserts[0].status != crate::RepoFrontierStatus::Active { return Err(anyhow!( "proposal Evolution frontier must be active so accepted unresolved work is immediately routeable" )); } if !matches!( upserts[0].recommended_next_organ.as_str(), "Hands" | "Eyes" | "Imagination" ) { return Err(anyhow!( "proposal Evolution frontier recommended_next_organ must be one exact routeable organ: Hands, Eyes, or Imagination" )); } if proposal.source_kind == crate::RepoFrontierProposalSourceKind::Imagination && (upserts[0].recommended_next_organ != "Imagination" || upserts[0].adopted_plan.is_some()) { return Err(anyhow!( "autonomous proposal Modeling may admit only an unadopted Imagination-planning frontier; Mind alone may adopt a plan before Hands" )); } request.request_id } else { if frontier_operation_count != 0 { return Err(anyhow!( "ordinary Evolution cannot mutate frontier without explicit proposal request" )); } String::new() }; ( String::new(), String::new(), String::new(), String::new(), request_id, String::new(), ) } crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { route_id, soul_verdict_receipt_id, } => { if result.proposal_modeling_request_id.is_some() || result.verification_request_id.is_some() || result.frontier_route_id.is_some() { return Err(anyhow!( "verdict incorporation result may carry only its frontier Modeling request echo" )); } let route = cache.get::(route_id)?.ok_or_else(|| { anyhow!("frontier verdict incorporation requires its exact route") })?; let verdict = cache .get::(soul_verdict_receipt_id)? .ok_or_else(|| { anyhow!("frontier verdict incorporation requires its exact Soul verdict") })?; let request = cache .get::(&verdict.verification_request_id)? .ok_or_else(|| { anyhow!("frontier verdict incorporation requires the Soul verification request") })?; let verification_results = cache .get_all::()? .into_iter() .filter(|candidate| candidate.result_id == verdict.source_result_id) .collect::>(); if verification_results.len() != 1 { return Err(anyhow!( "frontier verdict incorporation requires one immutable Verification result" )); } let verification_result = &verification_results[0]; let modeling_request_id = result .repo_frontier_modeling_request_id .as_deref() .ok_or_else(|| { anyhow!("frontier verdict incorporation must echo its typed Modeling request") })?; let modeling_request = cache .get::(modeling_request_id)? .ok_or_else(|| { anyhow!( "frontier verdict incorporation requires its persisted Modeling request" ) })?; let persisted_state = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| { anyhow!("frontier verdict incorporation requires persisted coordinator state") })? .state()?; let acceptance_matches = persisted_state .acceptance_receipts .iter() .filter(|acceptance| { acceptance.id == modeling_request.verification_acceptance_receipt_id }) .collect::>(); let mut verdict_evidence = verdict.evidence_ids.clone(); let mut verification_evidence = verification_result.evidence_ids.clone(); verdict_evidence.sort(); verdict_evidence.dedup(); verification_evidence.sort(); verification_evidence.dedup(); if route.schema_version != REPO_FRONTIER_ROUTE_SCHEMA_VERSION || route.contract != REPO_FRONTIER_ROUTE_CONTRACT || request.schema_version != REPO_FRONTIER_VERIFICATION_REQUEST_SCHEMA_VERSION || request.contract != REPO_FRONTIER_VERIFICATION_REQUEST_CONTRACT || verdict.schema_version != SOUL_VERDICT_RECEIPT_SCHEMA_VERSION || request.route_id != route.route_id || request.model_revision != route.model_revision || request.model_hash != route.model_hash || request.frontier_item_id != route.frontier_item_id || request.frontier_item_hash != route.frontier_item_hash || verdict.frontier_route_id != route.route_id || verdict.verification_request_id != request.request_id || !verification_result .role_id .eq_ignore_ascii_case("verification") || verification_result.schema_version != RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION || verification_result.item_error.is_some() || verification_result.result_id != verdict.source_result_id || verification_result.job_id != verdict.source_job_id || verification_result.verification_request_id.as_deref() != Some(request.request_id.as_str()) || verification_result.frontier_route_id.as_deref() != Some(route.route_id.as_str()) || verification_result.verdict != verdict.verdict || verification_result.summary != verdict.summary || verification_result.risks != verdict.risks || verification_evidence != verdict_evidence || modeling_request.schema_version != REPO_FRONTIER_MODELING_REQUEST_SCHEMA_VERSION || modeling_request.contract != REPO_FRONTIER_MODELING_REQUEST_CONTRACT || modeling_request.route_id != route.route_id || modeling_request.model_revision != route.model_revision || modeling_request.model_hash != route.model_hash || modeling_request.frontier_item_id != route.frontier_item_id || modeling_request.frontier_item_hash != route.frontier_item_hash || modeling_request.verification_request_id != request.request_id || modeling_request.soul_verdict_receipt_id != verdict.receipt_id || modeling_request.verification_result_id != verification_result.result_id || modeling_request.verification_job_id != verification_result.job_id || acceptance_matches.len() != 1 || acceptance_matches[0].role_id != "verification" || acceptance_matches[0].surface != "roleAccept" || acceptance_matches[0].status != "accepted" || acceptance_matches[0].result_id != verification_result.result_id || acceptance_matches[0].job_id != verification_result.job_id { return Err(anyhow!( "frontier verdict incorporation does not exactly bind route, request, Soul verdict, and Verification result" )); } if !result_evidence .iter() .any(|id| id == soul_verdict_receipt_id) { return Err(anyhow!( "frontier verdict incorporation Modeling evidence must include the exact Soul verdict receipt" )); } if patch.operations.len() != 1 { return Err(anyhow!( "frontier verdict incorporation permits exactly one frontier revision" )); } let crate::RepoModelPatchOperation::ReviseFrontier { item } = &patch.operations[0] else { return Err(anyhow!( "frontier verdict incorporation permits only ReviseFrontier" )); }; if item.id != route.frontier_item_id || !item .evidence_refs .iter() .any(|id| id == &request.request_id) || !item .evidence_refs .iter() .any(|id| id == soul_verdict_receipt_id) { return Err(anyhow!( "frontier verdict incorporation revision does not bind the routed item and evidence" )); } match verdict.verdict.trim().to_ascii_lowercase().as_str() { "pass" if item.status == crate::RepoFrontierStatus::Resolved && modeling_request.allowed_disposition == RepoFrontierVerdictDisposition::Resolved => {} "needs-review" | "needs-evidence" | "fail" if item.status == crate::RepoFrontierStatus::Blocked && !item.gap.trim().is_empty() && modeling_request.allowed_disposition == RepoFrontierVerdictDisposition::Blocked => {} _ => { return Err(anyhow!( "frontier verdict incorporation status does not match the Soul verdict" )); } } ( route.route_id, request.request_id, verdict.receipt_id, modeling_request.request_id, String::new(), String::new(), ) } }; let existing_review = cache.get::(&review.review_id)?; let existing_receipt = cache.get::(&receipt_id)?; match (existing_review, existing_receipt) { (Some(existing_review), Some(existing_receipt)) if existing_review == *review => { if existing_receipt.review_id != review.review_id || existing_receipt.result_id.as_deref() != Some(result_id) || existing_receipt.patch_id != patch.patch_id || existing_receipt.patch_sha256 != patch_sha256 || !crate::repo_model_admission_receipt_schema_supported( &existing_receipt.schema_version, &existing_receipt.contract, ) || existing_receipt.purpose != patch.purpose || existing_receipt.frontier_route_id != frontier_route_id || existing_receipt.verification_request_id != verification_request_id || existing_receipt.soul_verdict_receipt_id != soul_verdict_receipt_id || existing_receipt.frontier_modeling_request_id != frontier_modeling_request_id || existing_receipt.proposal_modeling_request_id != proposal_modeling_request_id || existing_receipt.claim_repair_request_id != claim_repair_request_id || !existing_receipt.frontier_plan_decision_id.is_empty() || existing_receipt.repository_body_observation_basis != review.repository_body_observation_basis { return Err(anyhow!("repo model admission receipt identity collision")); } require_modeling_projection_obligation_for_commit( &cache, &existing_receipt.receipt_id, existing_receipt.admitted_revision, &existing_receipt.admitted_hash, &existing_receipt.admitted_at, )?; return Ok(existing_receipt); } (None, None) => {} _ => return Err(anyhow!("repo model admission companion identity collision")), } let backing = SingleFileMessagePackBackingStore::new(runtime_store); let current_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("runtime repo model is missing"))?; let current_entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(¤t_envelope.payload)?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; if patch.purpose == crate::RepoModelPatchPurpose::Evolution { let current_hash = crate::memory_graph_model_hash(¤t)?; let current_has_route = cache .get_all::()? .into_iter() .any(|route| { route.model_revision == current.model_revision && route.model_hash == current_hash }); let owns_verdict_lifecycle = patch.operations.iter().any(|operation| match operation { crate::RepoModelPatchOperation::ReviseFrontier { item } => matches!( item.status, crate::RepoFrontierStatus::Blocked | crate::RepoFrontierStatus::Resolved | crate::RepoFrontierStatus::Retired | crate::RepoFrontierStatus::Superseded ), crate::RepoModelPatchOperation::RetireFrontier { .. } => true, _ => false, }); if current_has_route || owns_verdict_lifecycle { return Err(anyhow!( "Evolution cannot bypass a current route or own verdict-driven frontier lifecycle" )); } } if let crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { route_id, .. } = &patch.purpose { let modeling_request = cache .get::(&frontier_modeling_request_id)? .ok_or_else(|| { anyhow!("frontier verdict incorporation Modeling request disappeared") })?; let verification_request = cache .get::(&modeling_request.verification_request_id)? .ok_or_else(|| { anyhow!("frontier verdict incorporation verification request disappeared") })?; // This is deliberately adjacent to the model CAS: the complete Hands // chain must still be exact at the moment its consequence enters Mind. put_repo_frontier_verification_request(runtime_store, &verification_request)?; let route = cache .get::(route_id)? .ok_or_else(|| anyhow!("frontier verdict incorporation route disappeared"))?; let current_hash = crate::memory_graph_model_hash(¤t)?; let current_item = current .frontier .iter() .find(|item| item.id == route.frontier_item_id) .ok_or_else(|| anyhow!("frontier verdict incorporation routed item is missing"))?; let current_item_hash = format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(current_item)?) ); let crate::RepoModelPatchOperation::ReviseFrontier { item } = &patch.operations[0] else { unreachable!("purpose validation established one frontier revision") }; if current.model_revision != route.model_revision || current_hash != route.model_hash || current_item_hash != route.frontier_item_hash || current_item.status != crate::RepoFrontierStatus::Active || item.migration_body != current_item.migration_body || item.question != current_item.question || item.target_claim_ids != current_item.target_claim_ids || item.source_scope != current_item.source_scope || item.dependency_item_ids != current_item.dependency_item_ids || item.created_at != current_item.created_at || item.recommended_next_organ != current_item.recommended_next_organ || item.retired_at != current_item.retired_at || item.superseded_by != current_item.superseded_by { return Err(anyhow!( "frontier verdict incorporation requires the exact current routed item and preserves its identity-bearing anatomy" )); } } let next = crate::derive_repo_model_patch(¤t, &patch)?; let next_entry = crate::EpiphanyMemoryGraphEntry::from_snapshot(&next)?; let receipt = RepoModelAdmissionReceipt { schema_version: REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: receipt_id.clone(), review_id: review.review_id.clone(), result_id: Some(result_id.to_string()), patch_id: patch.patch_id.clone(), patch_sha256, previous_revision: current.model_revision, previous_hash: crate::memory_graph_model_hash(¤t)?, admitted_revision: next.model_revision, admitted_hash: next.model_hash.clone(), admitted_at: review.reviewed_at.clone(), contract: REPO_MODEL_ADMISSION_CONTRACT.to_string(), purpose: patch.purpose.clone(), frontier_route_id, verification_request_id, soul_verdict_receipt_id, frontier_modeling_request_id, proposal_modeling_request_id, claim_repair_request_id, frontier_plan_decision_id: String::new(), repository_body_observation_basis: review.repository_body_observation_basis.clone(), admission_source: expected_admission_source, }; let (next_model_envelope, _) = cache.prepare_entry(crate::MEMORY_GRAPH_KEY, &next_entry)?; let (review_envelope, _) = cache.prepare_entry(&review.review_id, review)?; let (receipt_envelope, _) = cache.prepare_entry(&receipt_id, &receipt)?; let obligation = modeling_projection_obligation(&cache, &next, &receipt.receipt_id, &receipt.admitted_at)?; let (obligation_envelope, _) = cache.prepare_entry(&obligation.obligation_id, &obligation)?; if !backing.compare_and_swap_batch( &[current_envelope], vec![ next_model_envelope, review_envelope, receipt_envelope, obligation_envelope, ], )? { return Err(anyhow!( "repo model admission stale model or companion collision" )); } Ok(receipt) } pub fn runtime_repo_model_admission_review( runtime_store: impl AsRef, review_id: &str, ) -> Result> { validate_non_empty(review_id, "repo model admission review id")?; let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; cache.get::(review_id) } pub fn runtime_repo_model_admission_receipt( runtime_store: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "repo model admission receipt id")?; let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } fn put_immutable_planning_entry( store_path: &Path, key: &str, value: &T, ) -> Result<()> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; if let Some(existing) = cache.get::(key)? { return if existing == *value { Ok(()) } else { Err(anyhow!("planning document ids are immutable")) }; } let (envelope, _) = cache.prepare_entry(key, value)?; let backing = SingleFileMessagePackBackingStore::new(store_path); if backing.compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(key)? { Some(existing) if existing == *value => Ok(()), _ => Err(anyhow!("planning document CAS collision")), } } pub(crate) fn validate_repo_frontier_work_proposal( proposal: &RepoFrontierWorkProposal, ) -> Result<()> { if proposal.schema_version != REPO_FRONTIER_WORK_PROPOSAL_SCHEMA_VERSION || proposal.contract != REPO_FRONTIER_WORK_PROPOSAL_CONTRACT || proposal.proposal_id.trim().is_empty() || proposal.source_actor.trim().is_empty() || proposal.source_ref.trim().is_empty() || proposal.repository.trim().is_empty() || proposal.workspace.trim().is_empty() || proposal.thread_id.trim().is_empty() || proposal.runtime_id.trim().is_empty() || proposal.title.trim().is_empty() || proposal.body.trim().is_empty() || proposal.desired_outcome.trim().is_empty() || proposal.private_state_included || chrono::DateTime::parse_from_rfc3339(&proposal.proposed_at).is_err() { return Err(anyhow!("invalid inert repo frontier work proposal")); } let content = rmp_serde::to_vec_named(&( &proposal.title, &proposal.body, &proposal.desired_outcome, &proposal.constraints, &proposal.scope_hints, &proposal.evidence_refs, ))?; if proposal.payload_sha256 != format!("{:x}", Sha256::digest(content)) { return Err(anyhow!("proposal content hash mismatch")); } Ok(()) } pub(crate) fn validate_autonomous_proposal_binding( cache: &CultCache, proposal: &RepoFrontierWorkProposal, ) -> Result { if proposal.source_kind != crate::RepoFrontierProposalSourceKind::Imagination { return Err(anyhow!( "autonomous binding requires an Imagination proposal" )); } let binding_id = format!("autonomous-proposal-binding-{}", proposal.proposal_id); let binding = cache .get::(&binding_id)? .ok_or_else(|| anyhow!("Imagination proposal lacks its autonomous origin binding"))?; let request = cache .get::(&binding.direction_request_id)? .ok_or_else(|| anyhow!("autonomous proposal binding lost its direction request"))?; let result = cache .get::(&binding.direction_result_id)? .ok_or_else(|| anyhow!("autonomous proposal binding lost its direction result"))?; let worker_result = cache .get::(&binding.direction_worker_job_id)? .ok_or_else(|| anyhow!("autonomous proposal binding lost its Imagination worker result"))?; let worker_launch = cache .get::(&binding.direction_worker_job_id)? .ok_or_else(|| anyhow!("autonomous proposal binding lost its Imagination worker launch"))?; crate::validate_current_admitted_model_direction_consideration_request(cache, &request)?; crate::validate_admitted_model_direction_consideration_result(&request, &result)?; let result_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&result)?)); let worker_result_sha256 = format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(&worker_result)?) ); let worker_launch_sha256 = format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(&worker_launch)?) ); let worker_direction = worker_result .admitted_model_direction_consideration_result()? .ok_or_else(|| anyhow!("autonomous proposal worker result lost its direction cargo"))?; let launch_projection = match worker_launch.launch_document()? { EpiphanyWorkerLaunchDocument::Role(document) => { document.admitted_model_direction_consideration_context } EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let option = result .option_drafts .get(binding.option_ordinal as usize) .ok_or_else(|| anyhow!("autonomous proposal binding names a missing option"))?; let option_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(option)?)); let route = cache .get::(crate::RUNTIME_BODY_STORE_BINDING_KEY)? .ok_or_else(|| anyhow!("autonomous proposal requires repository Body binding"))?; let domain = cache .get::(RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY)? .ok_or_else(|| anyhow!("autonomous proposal requires repository domain binding"))?; let (body_binding, _) = crate::load_repository_body_status(Path::new(&route.body_store_path))? .ok_or_else(|| anyhow!("autonomous proposal requires authenticated Body status"))?; let chain_checks = [ ( "worker result identity", binding.direction_worker_result_id == worker_result.result_id, ), ( "worker result hash", binding.direction_worker_result_sha256 == worker_result_sha256, ), ( "worker launch hash", binding.direction_worker_launch_sha256 == worker_launch_sha256, ), ( "worker job", worker_result.job_id == binding.direction_worker_job_id, ), ( "worker role", worker_result.role_id.eq_ignore_ascii_case("imagination"), ), ( "worker request echo", worker_result .admitted_model_direction_consideration_request_id .as_deref() == Some(request.request_id.as_str()), ), ("worker direction cargo", worker_direction == result), ( "direction launch identity", result.result_id == crate::admitted_model_direction_consideration_result_id_for_launch( &request.request_id, &binding.direction_worker_job_id, ), ), ( "launch role", worker_launch .role .eq_ignore_ascii_case(EPIPHANY_IMAGINATION_OWNER_ROLE), ), ( "launch binding", worker_launch.binding_id == EPIPHANY_IMAGINATION_ROLE_BINDING_ID, ), ( "launch request echo", worker_launch .admitted_model_direction_consideration_request_id .as_deref() == Some(request.request_id.as_str()), ), ( "launch request projection", launch_projection.map(|projection| projection.request) == Some(request.clone()), ), ]; if let Some((failed, _)) = chain_checks.into_iter().find(|(_, matches)| !matches) { return Err(anyhow!( "autonomous proposal Imagination chain mismatch: {failed}" )); } if binding.schema_version != REPO_FRONTIER_AUTONOMOUS_PROPOSAL_BINDING_SCHEMA_VERSION || binding.contract != REPO_FRONTIER_AUTONOMOUS_PROPOSAL_BINDING_CONTRACT || binding.binding_id != binding_id || binding.proposal_id != proposal.proposal_id || binding.proposal_payload_sha256 != proposal.payload_sha256 || binding.direction_request_id != result.request_id || binding.direction_result_id != result.result_id || binding.direction_result_sha256 != result_sha256 || binding.model_revision != result.model_revision || binding.model_hash != result.model_hash || binding.model_admission_receipt_id != result.model_admission_receipt_id || binding.option_sha256 != option_sha256 || binding.runtime_id != proposal.runtime_id || binding.thread_id != proposal.thread_id || binding.workspace_id != route.workspace_id || binding.body_binding_sha256 != route.body_binding_sha256 || domain.schema_version != RUNTIME_REPOSITORY_DOMAIN_BINDING_SCHEMA_VERSION || domain.contract != RUNTIME_REPOSITORY_DOMAIN_BINDING_CONTRACT || domain.binding_id != RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY || domain.repository_full_name != proposal.repository || domain.runtime_id != route.runtime_id || domain.swarm_id != route.swarm_id || domain.workspace_id != route.workspace_id || domain.body_binding_sha256 != route.body_binding_sha256 || body_binding.runtime_id != route.runtime_id || body_binding.swarm_id != route.swarm_id || body_binding.workspace_id != route.workspace_id || crate::repository_body_observer::body_binding_sha256(&body_binding)? != route.body_binding_sha256 || proposal.workspace != body_binding.git_top_level || chrono::DateTime::parse_from_rfc3339(&binding.created_at).is_err() || proposal.source_actor != EPIPHANY_IMAGINATION_OWNER_ROLE || proposal.source_ref != result.result_id || proposal.title != option.title || proposal.body != option.summary { return Err(anyhow!("autonomous proposal origin binding mismatch")); } Ok(binding) } pub(crate) fn validate_repo_frontier_proposal_modeling_request( request: &RepoFrontierProposalModelingRequest, ) -> Result<()> { if request.schema_version != REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION || request.contract != REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_CONTRACT || request.request_id.trim().is_empty() || request.proposal_id.trim().is_empty() || request.proposal_payload_sha256.trim().is_empty() || request.runtime_id.trim().is_empty() || request.thread_id.trim().is_empty() || request.repository.trim().is_empty() || request.workspace.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&request.selected_at).is_err() { return Err(anyhow!( "invalid coordinator repo frontier proposal Modeling request" )); } Ok(()) } pub fn put_repo_frontier_work_proposal( store_path: impl AsRef, proposal: &RepoFrontierWorkProposal, ) -> Result<()> { validate_repo_frontier_work_proposal(proposal)?; if proposal.source_kind == crate::RepoFrontierProposalSourceKind::Imagination { return Err(anyhow!( "generic proposal intake cannot author Imagination provenance" )); } let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; let identity = require_identity(&cache)?; if identity.runtime_id != proposal.runtime_id { return Err(anyhow!("proposal runtime identity mismatch")); } let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("proposal intake requires authoritative thread state"))?; if thread.thread_id != proposal.thread_id { return Err(anyhow!("proposal thread identity mismatch")); } put_immutable_planning_entry(store_path.as_ref(), &proposal.proposal_id, proposal) } pub fn intake_user_repo_frontier_proposal( store_path: impl AsRef, input: crate::RepoFrontierUserProposalInput, ) -> Result { let content = rmp_serde::to_vec_named(&( &input.title, &input.body, &input.desired_outcome, &input.constraints, &input.scope_hints, &input.evidence_refs, ))?; let proposal = RepoFrontierWorkProposal { schema_version: REPO_FRONTIER_WORK_PROPOSAL_SCHEMA_VERSION.into(), proposal_id: input.proposal_id, source_kind: crate::RepoFrontierProposalSourceKind::User, source_actor: input.source_actor, source_ref: input.source_ref, repository: input.repository, workspace: input.workspace, thread_id: input.thread_id, runtime_id: input.runtime_id, payload_sha256: format!("{:x}", Sha256::digest(content)), title: input.title, body: input.body, desired_outcome: input.desired_outcome, constraints: input.constraints, scope_hints: input.scope_hints, evidence_refs: input.evidence_refs, private_state_included: input.private_state_included, proposed_at: input.proposed_at, contract: REPO_FRONTIER_WORK_PROPOSAL_CONTRACT.into(), }; put_repo_frontier_work_proposal(store_path, &proposal)?; Ok(proposal) } pub fn runtime_repo_frontier_work_proposal( store_path: impl AsRef, proposal_id: &str, ) -> Result> { validate_non_empty(proposal_id, "repo frontier work proposal id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(proposal_id) } pub fn bind_runtime_repository_domain( runtime_store: impl AsRef, repository_full_name: &str, bound_at: &str, ) -> Result { if !repository_full_name.starts_with("GameCult/") || repository_full_name["GameCult/".len()..].trim().is_empty() || repository_full_name.chars().any(char::is_whitespace) { return Err(anyhow!( "runtime repository domain requires a canonical GameCult name" )); } chrono::DateTime::parse_from_rfc3339(bound_at) .map_err(|_| anyhow!("runtime repository domain timestamp must be RFC3339"))?; let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let identity = require_identity(&cache)?; let route = cache .get::(crate::RUNTIME_BODY_STORE_BINDING_KEY)? .ok_or_else(|| anyhow!("runtime repository domain requires Body binding"))?; let (body, _) = crate::load_repository_body_status(Path::new(&route.body_store_path))? .ok_or_else(|| anyhow!("runtime repository domain requires authenticated Body status"))?; if route.runtime_id != identity.runtime_id || body.runtime_id != route.runtime_id || body.swarm_id != route.swarm_id || body.workspace_id != route.workspace_id || crate::repository_body_observer::body_binding_sha256(&body)? != route.body_binding_sha256 { return Err(anyhow!("runtime repository domain Body authority mismatch")); } let binding = RuntimeRepositoryDomainBinding { schema_version: RUNTIME_REPOSITORY_DOMAIN_BINDING_SCHEMA_VERSION.into(), binding_id: RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY.into(), repository_full_name: repository_full_name.into(), runtime_id: route.runtime_id.clone(), swarm_id: route.swarm_id.clone(), workspace_id: route.workspace_id.clone(), body_binding_sha256: route.body_binding_sha256.clone(), bound_at: bound_at.into(), contract: RUNTIME_REPOSITORY_DOMAIN_BINDING_CONTRACT.into(), }; if let Some(existing) = cache.get::(RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY)? { let mut replay = binding; replay.bound_at = existing.bound_at.clone(); return if replay == existing { Ok(existing) } else { Err(anyhow!("runtime repository domain is immutable")) }; } let identity_envelope = cache .get_envelope::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("runtime repository domain identity disappeared"))?; let route_envelope = cache .get_envelope::( crate::RUNTIME_BODY_STORE_BINDING_KEY, )? .ok_or_else(|| anyhow!("runtime repository domain Body route disappeared"))?; let (binding_envelope, _) = cache.prepare_entry(RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY, &binding)?; let expected = vec![identity_envelope, route_envelope]; let mut replacement = expected.clone(); replacement.push(binding_envelope); if !SingleFileMessagePackBackingStore::new(runtime_store) .compare_and_swap_batch(&expected, replacement)? { return Err(anyhow!("runtime repository domain lost atomic binding")); } Ok(binding) } pub fn promote_autonomous_direction_options_for_modeling( runtime_store: impl AsRef, repository: &str, workspace: &str, selected_at: &str, ) -> Result> { chrono::DateTime::parse_from_rfc3339(selected_at) .map_err(|_| anyhow!("autonomous proposal promotion timestamp must be RFC3339"))?; validate_non_empty(repository, "autonomous proposal repository")?; validate_non_empty(workspace, "autonomous proposal workspace")?; let runtime_store = runtime_store.as_ref(); let mut opening = runtime_spine_cache(runtime_store)?; opening.pull_all_backing_stores()?; let identity = require_identity(&opening)?; let Some(thread) = opening.get::(crate::THREAD_STATE_KEY)? else { return Ok(Vec::new()); }; let Some(model) = opening.get::(crate::MEMORY_GRAPH_KEY)? else { return Ok(Vec::new()); }; let model = model.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let receipts = opening .get_all::()? .into_iter() .filter(|receipt| { receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .collect::>(); if receipts.is_empty() { return Ok(Vec::new()); } if receipts.len() != 1 { return Err(anyhow!( "autonomous proposal promotion requires one current model receipt" )); } let mut results = opening .get_all::()? .into_iter() .filter(|result| { result.disposition == crate::AdmittedModelDirectionDisposition::Suggest && result.model_revision == model.model_revision && result.model_hash == model_hash && result.model_admission_receipt_id == receipts[0].receipt_id }) .collect::>(); if results.is_empty() { return Ok(Vec::new()); } let route = opening .get::(crate::RUNTIME_BODY_STORE_BINDING_KEY)? .ok_or_else(|| anyhow!("autonomous proposal promotion requires Body binding"))?; if route.runtime_id != identity.runtime_id { return Err(anyhow!("autonomous proposal Body binding runtime mismatch")); } let domain = opening .get::(RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY)? .ok_or_else(|| { anyhow!("autonomous proposal promotion requires repository domain binding") })?; let body_store = PathBuf::from(&route.body_store_path); let (body_binding, _) = crate::load_repository_body_status(&body_store)? .ok_or_else(|| anyhow!("autonomous proposal Body store has no authenticated status"))?; if body_binding.workspace_id != route.workspace_id || body_binding.runtime_id != route.runtime_id || body_binding.swarm_id != route.swarm_id || crate::repository_body_observer::body_binding_sha256(&body_binding)? != route.body_binding_sha256 || Path::new(workspace).canonicalize()? != Path::new(&body_binding.git_top_level).canonicalize()? || domain.schema_version != RUNTIME_REPOSITORY_DOMAIN_BINDING_SCHEMA_VERSION || domain.contract != RUNTIME_REPOSITORY_DOMAIN_BINDING_CONTRACT || domain.binding_id != RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY || domain.repository_full_name != repository || domain.runtime_id != route.runtime_id || domain.swarm_id != route.swarm_id || domain.workspace_id != route.workspace_id || domain.body_binding_sha256 != route.body_binding_sha256 { return Err(anyhow!( "autonomous proposal workspace is not the bound repository Body" )); } results.sort_by(|left, right| left.result_id.cmp(&right.result_id)); let mut promoted = Vec::new(); for result in results { let request = opening .get::(&result.request_id)? .ok_or_else(|| anyhow!("autonomous proposal result lost its request"))?; crate::validate_admitted_model_direction_consideration_result(&request, &result)?; let mut direction_workers = opening .get_all::()? .into_iter() .filter_map(|worker| { worker .admitted_model_direction_consideration_result() .ok() .flatten() .filter(|embedded| embedded == &result) .map(|_| worker) }) .collect::>(); if direction_workers.len() != 1 { return Err(anyhow!( "autonomous proposal requires exactly one immutable Imagination worker result" )); } let direction_worker = direction_workers.remove(0); let direction_launch = opening .get::(&direction_worker.job_id)? .ok_or_else(|| anyhow!("autonomous proposal direction worker lost its launch"))?; let direction_worker_result_sha256 = format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(&direction_worker)?) ); let direction_worker_launch_sha256 = format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(&direction_launch)?) ); let result_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&result)?)); for (ordinal, option) in result.option_drafts.iter().enumerate() { if option.title.trim().is_empty() || option.summary.trim().is_empty() { return Err(anyhow!("autonomous direction option is empty")); } let option_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(option)?)); let proposal_id = format!( "repo-frontier-autonomous-{:x}", Sha256::digest(rmp_serde::to_vec_named(&( &result.result_id, ordinal as u32, &option_sha256 ))?) ); let evidence_refs = result .evidence_refs .iter() .cloned() .chain([ format!( "cultcache://admitted-model-direction/{}", request.request_id ), format!( "cultcache://admitted-model-direction-result/{}", result.result_id ), format!( "cultcache://repo-model-admission/{}", result.model_admission_receipt_id ), ]) .collect::>(); let content = rmp_serde::to_vec_named(&( &option.title, &option.summary, &option.summary, &result.uncertainties, &Vec::::new(), &evidence_refs, ))?; let payload_sha256 = format!("{:x}", Sha256::digest(content)); let proposal = RepoFrontierWorkProposal { schema_version: REPO_FRONTIER_WORK_PROPOSAL_SCHEMA_VERSION.into(), proposal_id: proposal_id.clone(), source_kind: crate::RepoFrontierProposalSourceKind::Imagination, source_actor: EPIPHANY_IMAGINATION_OWNER_ROLE.into(), source_ref: result.result_id.clone(), repository: repository.into(), workspace: body_binding.git_top_level.clone(), thread_id: thread.thread_id.clone(), runtime_id: identity.runtime_id.clone(), payload_sha256: payload_sha256.clone(), title: option.title.clone(), body: option.summary.clone(), desired_outcome: option.summary.clone(), constraints: result.uncertainties.clone(), scope_hints: Vec::new(), evidence_refs, private_state_included: false, proposed_at: result.proposed_at.clone(), contract: REPO_FRONTIER_WORK_PROPOSAL_CONTRACT.into(), }; validate_repo_frontier_work_proposal(&proposal)?; let binding = RepoFrontierAutonomousProposalBinding { schema_version: REPO_FRONTIER_AUTONOMOUS_PROPOSAL_BINDING_SCHEMA_VERSION.into(), binding_id: format!("autonomous-proposal-binding-{proposal_id}"), proposal_id: proposal_id.clone(), proposal_payload_sha256: payload_sha256.clone(), direction_request_id: request.request_id.clone(), direction_result_id: result.result_id.clone(), direction_result_sha256: result_sha256.clone(), model_revision: result.model_revision, model_hash: result.model_hash.clone(), model_admission_receipt_id: result.model_admission_receipt_id.clone(), option_ordinal: ordinal as u32, option_sha256, runtime_id: identity.runtime_id.clone(), thread_id: thread.thread_id.clone(), workspace_id: route.workspace_id.clone(), body_binding_sha256: route.body_binding_sha256.clone(), created_at: selected_at.into(), contract: REPO_FRONTIER_AUTONOMOUS_PROPOSAL_BINDING_CONTRACT.into(), direction_worker_job_id: direction_worker.job_id.clone(), direction_worker_result_id: direction_worker.result_id.clone(), direction_worker_result_sha256: direction_worker_result_sha256.clone(), direction_worker_launch_sha256: direction_worker_launch_sha256.clone(), }; let selection = RepoFrontierProposalModelingRequest { schema_version: REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION.into(), request_id: format!( "repo-frontier-proposal-modeling-{:x}", Sha256::digest(format!("{}:{}", proposal_id, payload_sha256).as_bytes()) ), proposal_id: proposal_id.clone(), proposal_payload_sha256: payload_sha256, runtime_id: identity.runtime_id.clone(), thread_id: thread.thread_id.clone(), repository: repository.into(), workspace: body_binding.git_top_level.clone(), selected_at: selected_at.into(), contract: REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_CONTRACT.into(), }; validate_repo_frontier_proposal_modeling_request(&selection)?; let mut current = runtime_spine_cache(runtime_store)?; current.pull_all_backing_stores()?; let existing = ( current.get::(&proposal.proposal_id)?, current.get::(&binding.binding_id)?, current.get::(&selection.request_id)?, ); if let (Some(existing_proposal), Some(_), Some(existing_selection)) = &existing { validate_autonomous_proposal_binding(¤t, existing_proposal)?; let mut replay_selection = selection.clone(); replay_selection.selected_at = existing_selection.selected_at.clone(); if existing_proposal == &proposal && existing_selection == &replay_selection { promoted.push(existing_selection.clone()); continue; } } if existing.0.is_some() || existing.1.is_some() || existing.2.is_some() { return Err(anyhow!("autonomous proposal promotion companion collision")); } let (proposal_envelope, _) = current.prepare_entry(&proposal.proposal_id, &proposal)?; let (binding_envelope, _) = current.prepare_entry(&binding.binding_id, &binding)?; let (selection_envelope, _) = current.prepare_entry(&selection.request_id, &selection)?; let expected = vec![ current .get_envelope::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("runtime identity envelope disappeared"))?, current .get_envelope::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("thread envelope disappeared"))?, current .get_envelope::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("model envelope disappeared"))?, current .get_envelope::(&result.model_admission_receipt_id)? .ok_or_else(|| anyhow!("model receipt envelope disappeared"))?, current .get_envelope::( crate::RUNTIME_BODY_STORE_BINDING_KEY, )? .ok_or_else(|| anyhow!("Body route envelope disappeared"))?, current .get_envelope::( RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY, )? .ok_or_else(|| anyhow!("repository domain envelope disappeared"))?, current .get_envelope::( &request.request_id, )? .ok_or_else(|| anyhow!("direction request envelope disappeared"))?, current .get_envelope::( &result.result_id, )? .ok_or_else(|| anyhow!("direction result envelope disappeared"))?, current .get_envelope::(&direction_worker.job_id)? .ok_or_else(|| anyhow!("direction launch envelope disappeared"))?, current .get_envelope::(&direction_worker.job_id)? .ok_or_else(|| anyhow!("direction worker envelope disappeared"))?, ]; let mut replacement = expected.clone(); replacement.extend([proposal_envelope, binding_envelope, selection_envelope]); if !SingleFileMessagePackBackingStore::new(runtime_store) .compare_and_swap_batch(&expected, replacement)? { return Err(anyhow!( "autonomous proposal promotion lost atomic insertion" )); } promoted.push(selection); } } Ok(promoted) } pub fn runtime_repo_frontier_proposal_modeling_request( store_path: impl AsRef, request_id: &str, ) -> Result> { validate_non_empty(request_id, "repo frontier proposal Modeling request id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(request_id) } pub fn runtime_current_repo_model( store_path: impl AsRef, ) -> Result> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache .get::(crate::MEMORY_GRAPH_KEY)? .map(|entry| entry.snapshot()) .transpose() } pub fn runtime_modeling_semantic_projection_input( store_path: impl AsRef, ) -> Result { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let binding = require_runtime_swarm_binding(&cache)?; let entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("Modeling projection requires admitted RepoModel"))?; let snapshot = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&snapshot)?; let canonical_source_id = format!("epiphany.runtime/{}/repo-model", binding.runtime_id); let matches = cache .get_all::()? .into_iter() .filter(|obligation| { obligation.swarm_id == binding.swarm_id && obligation.partition == "modeling" && obligation.canonical_source_id == canonical_source_id && obligation.graph_id == snapshot.graph_id && obligation.source_generation == snapshot.model_revision && obligation.source_model_hash == model_hash }) .collect::>(); if matches.len() != 1 { return Err(anyhow!( "Modeling projection requires exactly one obligation for current RepoModel" )); } let obligation = matches.into_iter().next().expect("one obligation"); let expected = crate::derive_memory_semantic_projection_obligation( &snapshot, &binding.swarm_id, crate::SemanticPartition::Modeling, &canonical_source_id, &obligation.source_commit_id, &obligation.created_at, )?; if obligation != expected { return Err(anyhow!( "Modeling projection obligation does not match canonical RepoModel" )); } let opening = cache.snapshot_envelopes(); let authority_envelopes = opening .into_iter() .filter(|envelope| { (envelope.r#type == RUNTIME_SWARM_BINDING_TYPE && envelope.key == RUNTIME_SWARM_BINDING_KEY) || (envelope.r#type == crate::MEMORY_GRAPH_TYPE && envelope.key == crate::MEMORY_GRAPH_KEY) }) .collect::>(); if authority_envelopes.len() != 2 { return Err(anyhow!( "Modeling projection authority snapshot is incomplete" )); } Ok(crate::MemorySemanticProjectionInput { snapshot, authority: crate::memory_graph::MemorySemanticProjectionAuthoritySnapshot { head: crate::MemorySemanticProjectionSourceHead { swarm_id: obligation.swarm_id.clone(), partition: obligation.partition.clone(), canonical_source_id: obligation.canonical_source_id.clone(), source_commit_id: obligation.source_commit_id.clone(), graph_id: obligation.graph_id.clone(), source_generation: obligation.source_generation, source_model_hash: obligation.source_model_hash.clone(), canonical_content_set_hash: obligation.canonical_content_set_hash.clone(), }, envelopes: authority_envelopes, }, obligation, }) } pub fn select_repo_frontier_work_proposal_for_modeling( store_path: impl AsRef, proposal_id: &str, selected_at: &str, ) -> Result { chrono::DateTime::parse_from_rfc3339(selected_at) .map_err(|_| anyhow!("proposal selection timestamp must be RFC3339"))?; let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let identity = require_identity(&cache)?; let proposal = cache .get::(proposal_id)? .ok_or_else(|| anyhow!("proposal selection requires exact persisted proposal"))?; validate_repo_frontier_work_proposal(&proposal)?; if proposal.source_kind == crate::RepoFrontierProposalSourceKind::Imagination { validate_autonomous_proposal_binding(&cache, &proposal)?; } let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("proposal selection requires authoritative thread state"))?; if proposal.runtime_id != identity.runtime_id || proposal.thread_id != thread.thread_id { return Err(anyhow!("proposal selection provenance mismatch")); } let existing_requests = cache.get_all::()?; for receipt in cache.get_all::()? { if receipt.proposal_modeling_request_id.is_empty() { continue; } let incorporated = cache .get::(&receipt.proposal_modeling_request_id)? .ok_or_else(|| anyhow!("admission names missing proposal request"))?; validate_repo_frontier_proposal_modeling_request(&incorporated)?; if incorporated.proposal_id == proposal_id { return Err(anyhow!("proposal already incorporated")); } } let request_id = format!( "repo-frontier-proposal-modeling-{:x}", Sha256::digest(format!("{}:{}", proposal.proposal_id, proposal.payload_sha256).as_bytes()) ); let request = RepoFrontierProposalModelingRequest { schema_version: REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION.into(), request_id: request_id.clone(), proposal_id: proposal.proposal_id.clone(), proposal_payload_sha256: proposal.payload_sha256.clone(), runtime_id: proposal.runtime_id.clone(), thread_id: proposal.thread_id.clone(), repository: proposal.repository.clone(), workspace: proposal.workspace.clone(), selected_at: selected_at.into(), contract: REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_CONTRACT.into(), }; if let Some(existing) = existing_requests .into_iter() .find(|r| r.proposal_id == proposal_id) { validate_repo_frontier_proposal_modeling_request(&existing)?; return if existing == request { Ok(existing) } else { Err(anyhow!("proposal selection identity conflict")) }; } match put_immutable_planning_entry(store_path, &request_id, &request) { Ok(()) => Ok(request), Err(error) => { let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; if let Some(existing) = reloaded.get::(&request_id)? { if existing == request { return Ok(existing); } } Err(error) } } } pub fn select_and_commit_repo_frontier_planning_request( runtime_store: impl AsRef, at: &str, ) -> Result { chrono::DateTime::parse_from_rfc3339(at) .map_err(|_| anyhow!("planning request timestamp must be RFC3339"))?; let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let identity = require_identity(&cache)?; let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("planning request requires authoritative thread state"))?; thread.state()?; let backing = SingleFileMessagePackBackingStore::new(runtime_store); let model_envelope = backing .pull_all()? .into_iter() .find(|e| e.r#type == crate::MEMORY_GRAPH_TYPE && e.key == crate::MEMORY_GRAPH_KEY) .ok_or_else(|| anyhow!("planning requires canonical model"))?; let entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(&model_envelope.payload)?; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let receipts = cache .get_all::()? .into_iter() .filter(|r| { crate::repo_model_admission_receipt_schema_supported(&r.schema_version, &r.contract) && r.admitted_revision == model.model_revision && r.admitted_hash == model_hash }) .collect::>(); if receipts.len() != 1 { return Err(anyhow!( "planning requires exactly one current admission receipt" )); } let challenges = current_repo_model_claim_challenges(&cache, &model, &model_hash)?; let item = actionable_imagination_frontier_item(&model, &challenges) .ok_or_else(|| anyhow!("planning requires an actionable Imagination frontier"))?; let item_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)); let request_id = format!( "repo-frontier-planning-{:x}", Sha256::digest( format!( "{}:{}:{model_hash}:{}:{item_hash}", identity.runtime_id, thread.thread_id, item.id ) .as_bytes(), ) ); if cache .get_all::()? .iter() .any(|decision| decision.planning_request_id == request_id) { return Err(anyhow!( "current frontier planning request already has a terminal Mind decision" )); } let request = RepoFrontierPlanningRequest { schema_version: REPO_FRONTIER_PLANNING_REQUEST_SCHEMA_VERSION.into(), request_id: request_id.clone(), model_revision: model.model_revision, model_hash, admission_receipt_id: receipts[0].receipt_id.clone(), frontier_item_id: item.id.clone(), frontier_item_hash: item_hash, selected_organ: "Imagination".into(), source_scope: item.source_scope.clone(), requested_at: at.into(), contract: REPO_FRONTIER_PLANNING_CONTRACT.into(), runtime_id: identity.runtime_id, thread_id: thread.thread_id, }; if let Some(existing) = cache.get::(&request_id)? { let mut retry = request.clone(); retry.requested_at = existing.requested_at.clone(); return if existing == retry { Ok(existing) } else { Err(anyhow!("planning request identity collision")) }; } let (envelope, _) = cache.prepare_entry(&request_id, &request)?; if !backing.compare_and_swap_batch(&[model_envelope.clone()], vec![model_envelope, envelope])? { let mut reloaded = runtime_spine_cache(runtime_store)?; reloaded.pull_all_backing_stores()?; if let Some(existing) = reloaded.get::(&request_id)? { let mut retry = request; retry.requested_at = existing.requested_at.clone(); return if existing == retry { Ok(existing) } else { Err(anyhow!("planning request CAS collision")) }; } return Err(anyhow!("planning request lost current-model CAS")); } Ok(request) } pub(crate) fn validate_current_repo_frontier_planning_request( cache: &CultCache, request: &RepoFrontierPlanningRequest, ) -> Result<()> { chrono::DateTime::parse_from_rfc3339(&request.requested_at) .map_err(|_| anyhow!("planning request timestamp must be RFC3339"))?; let identity = require_identity(cache)?; let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("planning request requires authoritative thread state"))?; thread.state()?; let entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("planning request requires canonical model"))?; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let receipts = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .collect::>(); if receipts.len() != 1 { return Err(anyhow!( "planning request requires exactly one current admission receipt" )); } let challenges = current_repo_model_claim_challenges(cache, &model, &model_hash)?; let item = actionable_imagination_frontier_item(&model, &challenges) .ok_or_else(|| anyhow!("planning request frontier is no longer actionable"))?; let item_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)); let expected_request_id = format!( "repo-frontier-planning-{:x}", Sha256::digest( format!( "{}:{}:{model_hash}:{}:{item_hash}", identity.runtime_id, thread.thread_id, item.id ) .as_bytes(), ) ); if request.schema_version != REPO_FRONTIER_PLANNING_REQUEST_SCHEMA_VERSION || request.contract != REPO_FRONTIER_PLANNING_CONTRACT || request.request_id != expected_request_id || request.model_revision != model.model_revision || request.model_hash != model_hash || request.admission_receipt_id != receipts[0].receipt_id || request.frontier_item_id != item.id || request.frontier_item_hash != item_hash || request.selected_organ != "Imagination" || request.source_scope != item.source_scope || request.runtime_id != identity.runtime_id || request.thread_id != thread.thread_id { return Err(anyhow!( "planning request does not exactly bind current model, frontier, runtime, and thread" )); } Ok(()) } pub fn commit_repo_frontier_plan_mind_request( runtime_store: impl AsRef, imagination_result_id: &str, requested_at: &str, ) -> Result { chrono::DateTime::parse_from_rfc3339(requested_at) .map_err(|_| anyhow!("Mind request timestamp must be RFC3339"))?; let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let results = cache .get_all::()? .into_iter() .filter(|result| result.result_id == imagination_result_id) .collect::>(); if results.len() != 1 { return Err(anyhow!( "Mind request requires exactly one immutable Imagination result" )); } let result = &results[0]; put_runtime_role_worker_result(runtime_store, result)?; let planning_request_id = result .frontier_planning_request_id .as_deref() .ok_or_else(|| anyhow!("Mind request source lacks planning request echo"))?; let planning = cache .get::(planning_request_id)? .ok_or_else(|| anyhow!("Mind request source planning request disappeared"))?; let candidate = result .frontier_plan_candidate()? .ok_or_else(|| anyhow!("Mind request source candidate disappeared"))?; validate_current_repo_frontier_planning_request(&cache, &planning)?; validate_repo_frontier_plan_candidate_against_request(&cache, &candidate, &planning)?; let candidate_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&candidate)?)); let request_id = format!( "repo-frontier-plan-mind-{:x}", Sha256::digest( format!( "{}:{}:{}:{}", planning.runtime_id, planning.thread_id, result.result_id, candidate_sha256 ) .as_bytes() ) ); let request = RepoFrontierPlanMindRequest { schema_version: REPO_FRONTIER_PLAN_MIND_REQUEST_SCHEMA_VERSION.into(), request_id: request_id.clone(), planning_request_id: planning.request_id, imagination_result_id: result.result_id.clone(), imagination_job_id: result.job_id.clone(), candidate_id: candidate.candidate_id, candidate_sha256, runtime_id: planning.runtime_id, thread_id: planning.thread_id, requested_at: requested_at.into(), contract: REPO_FRONTIER_PLAN_MIND_REQUEST_CONTRACT.into(), }; if let Some(existing) = cache.get::(&request_id)? { let mut retry = request.clone(); retry.requested_at = existing.requested_at.clone(); return if existing == retry { Ok(existing) } else { Err(anyhow!("Mind request identity collision")) }; } let (envelope, _) = cache.prepare_entry(&request_id, &request)?; let backing = SingleFileMessagePackBackingStore::new(runtime_store); let current_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("Mind request requires canonical RepoModel"))?; let current_entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(¤t_envelope.payload)?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; if current.model_revision != planning.model_revision || crate::memory_graph_model_hash(¤t)? != planning.model_hash { return Err(anyhow!( "Mind request model changed before immutable insert" )); } if !backing.compare_and_swap_batch( std::slice::from_ref(¤t_envelope), vec![current_envelope.clone(), envelope], )? { return Err(anyhow!( "Mind request lost current-model CAS or immutable request claim" )); } Ok(request) } pub(crate) fn validate_repo_frontier_plan_mind_request( cache: &CultCache, request: &RepoFrontierPlanMindRequest, ) -> Result<(RepoFrontierPlanningRequest, RepoFrontierPlanCandidate)> { let (planning, candidate) = validate_repo_frontier_plan_mind_request_identity(cache, request)?; validate_current_repo_frontier_planning_request(cache, &planning)?; validate_repo_frontier_plan_candidate_against_request(cache, &candidate, &planning)?; Ok((planning, candidate)) } fn validate_repo_frontier_plan_mind_request_identity( cache: &CultCache, request: &RepoFrontierPlanMindRequest, ) -> Result<(RepoFrontierPlanningRequest, RepoFrontierPlanCandidate)> { if request.schema_version != REPO_FRONTIER_PLAN_MIND_REQUEST_SCHEMA_VERSION || request.contract != REPO_FRONTIER_PLAN_MIND_REQUEST_CONTRACT || chrono::DateTime::parse_from_rfc3339(&request.requested_at).is_err() { return Err(anyhow!("invalid typed Mind request")); } let result = cache .get_all::()? .into_iter() .find(|r| r.result_id == request.imagination_result_id) .ok_or_else(|| anyhow!("Mind request source result disappeared"))?; let planning = cache .get::(&request.planning_request_id)? .ok_or_else(|| anyhow!("Mind request planning request disappeared"))?; let candidate = result .frontier_plan_candidate()? .ok_or_else(|| anyhow!("Mind request candidate disappeared"))?; let hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&candidate)?)); if result.job_id != request.imagination_job_id || result.frontier_planning_request_id.as_deref() != Some(request.planning_request_id.as_str()) || candidate.candidate_id != request.candidate_id || hash != request.candidate_sha256 || request.runtime_id != planning.runtime_id || request.thread_id != planning.thread_id { return Err(anyhow!( "Mind request substituted immutable Imagination causal identity" )); } Ok((planning, candidate)) } fn actionable_imagination_frontier_item<'a>( model: &'a crate::EpiphanyMemoryGraphSnapshot, challenges: &[RepoModelClaimChallenge], ) -> Option<&'a crate::RepoFrontierItem> { let terminal = |id: &str| { model .frontier .iter() .find(|item| item.id == id) .is_some_and(|item| { matches!( item.status, crate::RepoFrontierStatus::Resolved | crate::RepoFrontierStatus::Retired | crate::RepoFrontierStatus::Superseded ) }) }; let mut eligible = model .frontier .iter() .filter(|item| { item.status == crate::RepoFrontierStatus::Active && item.recommended_next_organ == "Imagination" && !item.source_scope.is_empty() && safe_sorted_unique_paths(&item.source_scope) && frontier_target_claims_unchallenged(item, challenges) && item.dependency_item_ids.iter().all(|id| terminal(id)) }) .collect::>(); eligible.sort_by(|a, b| a.id.cmp(&b.id)); eligible.into_iter().next() } fn frontier_target_claims_unchallenged( item: &crate::RepoFrontierItem, challenges: &[RepoModelClaimChallenge], ) -> bool { !challenges .iter() .any(|challenge| item.target_claim_ids.contains(&challenge.target_claim_id)) } fn current_repo_model_claim_challenges( cache: &CultCache, model: &crate::EpiphanyMemoryGraphSnapshot, model_hash: &str, ) -> Result> { let mut current = Vec::new(); for challenge in cache.get_all::()? { let Some(claim) = model .nodes .iter() .find(|node| node.id == challenge.target_claim_id) else { continue; }; if format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(claim)?)) == challenge.target_claim_sha256 { validate_repo_model_claim_challenge_chain(cache, model, model_hash, &challenge, false)?; current.push(challenge); } } Ok(current) } fn validate_repo_model_claim_challenge_chain( cache: &CultCache, model: &crate::EpiphanyMemoryGraphSnapshot, model_hash: &str, challenge: &RepoModelClaimChallenge, require_current_model: bool, ) -> Result<()> { if challenge.schema_version != REPO_MODEL_CLAIM_CHALLENGE_SCHEMA_VERSION || challenge.contract != REPO_MODEL_CLAIM_CHALLENGE_CONTRACT || challenge.challenge_id.trim().is_empty() || challenge.finding.trim().is_empty() || challenge.uncertainty.trim().is_empty() || challenge.source_refs.is_empty() || challenge.evidence_ids.is_empty() || chrono::DateTime::parse_from_rfc3339(&challenge.challenged_at).is_err() { return Err(anyhow!("invalid repo model claim challenge")); } let packet = cache .get::(&challenge.eyes_evidence_packet_id)? .ok_or_else(|| anyhow!("claim challenge requires exact Eyes evidence packet"))?; if packet.schema_version != EYES_EVIDENCE_PACKET_SCHEMA_VERSION || packet.contract.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&packet.emitted_at).is_err() || packet.source_result_id != challenge.source_result_id || packet.source_job_id != challenge.source_job_id || packet.source_refs != challenge.source_refs || packet.evidence_ids != challenge.evidence_ids || format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&packet)?)) != challenge.eyes_evidence_packet_sha256 { return Err(anyhow!("claim challenge substituted Eyes evidence")); } if require_current_model && (challenge.model_revision != model.model_revision || challenge.model_hash != model_hash) { return Err(anyhow!("claim challenge model revision is stale")); } let receipts = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == challenge.model_revision && receipt.admitted_hash == challenge.model_hash }) .collect::>(); if receipts.len() != 1 || receipts[0].receipt_id != challenge.admission_receipt_id { return Err(anyhow!( "claim challenge requires the unique current admission receipt" )); } let claim = model .nodes .iter() .find(|node| node.id == challenge.target_claim_id) .ok_or_else(|| anyhow!("claim challenge target claim is missing"))?; if format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(claim)?)) != challenge.target_claim_sha256 { return Err(anyhow!("claim challenge target claim identity mismatch")); } Ok(()) } pub fn commit_repo_model_claim_challenge( store_path: impl AsRef, challenge: &RepoModelClaimChallenge, ) -> Result<()> { if challenge.schema_version != REPO_MODEL_CLAIM_CHALLENGE_SCHEMA_VERSION || challenge.contract != REPO_MODEL_CLAIM_CHALLENGE_CONTRACT || challenge.challenge_id.trim().is_empty() || challenge.finding.trim().is_empty() || challenge.uncertainty.trim().is_empty() || challenge.source_refs.is_empty() || challenge.evidence_ids.is_empty() || chrono::DateTime::parse_from_rfc3339(&challenge.challenged_at).is_err() { return Err(anyhow!("invalid repo model claim challenge")); } let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let backing = SingleFileMessagePackBackingStore::new(store_path); let envelopes = backing.pull_all()?; let model_envelope = envelopes .iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .cloned() .ok_or_else(|| anyhow!("claim challenge requires canonical model"))?; let entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(&model_envelope.payload)?; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; if challenge.model_revision != model.model_revision || challenge.model_hash != model_hash { return Err(anyhow!("claim challenge model revision is stale")); } validate_repo_model_claim_challenge_chain(&cache, &model, &model_hash, challenge, true)?; if let Some(existing) = cache.get::(&challenge.challenge_id)? { return if existing == *challenge { Ok(()) } else { Err(anyhow!("claim challenge ids are immutable")) }; } let packet_envelope = envelopes .iter() .find(|entry| { entry.r#type == EYES_EVIDENCE_PACKET_TYPE && entry.key == challenge.eyes_evidence_packet_id }) .cloned() .ok_or_else(|| anyhow!("claim challenge packet envelope is missing"))?; let admission_envelope = envelopes .iter() .find(|entry| { entry.r#type == REPO_MODEL_ADMISSION_RECEIPT_TYPE && entry.key == challenge.admission_receipt_id }) .cloned() .ok_or_else(|| anyhow!("claim challenge admission envelope is missing"))?; let (challenge_envelope, _) = cache.prepare_entry(&challenge.challenge_id, challenge)?; if !backing.compare_and_swap_batch( &[ model_envelope.clone(), packet_envelope.clone(), admission_envelope.clone(), ], vec![ model_envelope, packet_envelope, admission_envelope, challenge_envelope, ], )? { let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; return match reloaded.get::(&challenge.challenge_id)? { Some(existing) if existing == *challenge => Ok(()), Some(_) => Err(anyhow!("claim challenge immutable collision")), None => Err(anyhow!("claim challenge lost exact model/packet CAS")), }; } Ok(()) } pub fn commit_repo_model_claim_repair_request( store_path: impl AsRef, challenge_id: &str, requested_at: &str, ) -> Result { validate_non_empty(challenge_id, "claim repair challenge id")?; chrono::DateTime::parse_from_rfc3339(requested_at) .map_err(|_| anyhow!("claim repair request timestamp must be RFC3339"))?; let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let backing = SingleFileMessagePackBackingStore::new(store_path); let envelopes = backing.pull_all()?; let model_envelope = envelopes .iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .cloned() .ok_or_else(|| anyhow!("claim repair request requires canonical model"))?; let entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(&model_envelope.payload)?; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let challenge = cache .get::(challenge_id)? .ok_or_else(|| anyhow!("claim repair request requires exact challenge"))?; validate_repo_model_claim_challenge_chain(&cache, &model, &model_hash, &challenge, false)?; let packet = cache .get::(&challenge.eyes_evidence_packet_id)? .ok_or_else(|| anyhow!("claim repair request requires exact Eyes packet"))?; let original_admission = cache .get::(&challenge.admission_receipt_id)? .ok_or_else(|| anyhow!("claim repair request requires original challenge admission"))?; let identity = cache .get::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("claim repair request requires runtime identity"))?; let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("claim repair request requires authoritative thread"))?; let claim = model .nodes .iter() .find(|node| node.id == challenge.target_claim_id) .ok_or_else(|| anyhow!("claim repair target is no longer present"))?; if format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(claim)?)) != challenge.target_claim_sha256 { return Err(anyhow!( "claim repair challenge is already resolved by a changed claim" )); } let receipts = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .collect::>(); if receipts.len() != 1 { return Err(anyhow!( "claim repair request requires unique current admission receipt" )); } let challenge_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&challenge)?)); let request_id = format!("repo-model-claim-repair-{challenge_id}"); let mut affected_frontier = model .frontier .iter() .filter(|item| item.target_claim_ids.contains(&challenge.target_claim_id)) .map(|item| { Ok(crate::RepoModelClaimRepairFrontierRef { frontier_item_id: item.id.clone(), frontier_item_sha256: format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?) ), }) }) .collect::>>()?; affected_frontier.sort_by(|a, b| a.frontier_item_id.cmp(&b.frontier_item_id)); let request = RepoModelClaimRepairRequest { schema_version: REPO_MODEL_CLAIM_REPAIR_REQUEST_SCHEMA_VERSION.into(), request_id: request_id.clone(), challenge_id: challenge.challenge_id.clone(), challenge_sha256, eyes_evidence_packet_id: packet.packet_id.clone(), eyes_evidence_packet_sha256: challenge.eyes_evidence_packet_sha256.clone(), source_result_id: challenge.source_result_id.clone(), source_job_id: challenge.source_job_id.clone(), original_admission_receipt_id: original_admission.receipt_id.clone(), current_admission_receipt_id: receipts[0].receipt_id.clone(), model_revision: model.model_revision, model_hash, target_claim_id: challenge.target_claim_id.clone(), target_claim_sha256: challenge.target_claim_sha256.clone(), runtime_id: identity.runtime_id.clone(), thread_id: thread.thread_id.clone(), affected_frontier, requested_at: requested_at.to_string(), contract: REPO_MODEL_CLAIM_REPAIR_REQUEST_CONTRACT.into(), }; validate_current_repo_model_claim_repair_request(&cache, &request)?; if let Some(existing) = cache.get::(&request_id)? { return if existing == request { Ok(existing) } else { Err(anyhow!("claim repair request identity collision")) }; } let challenge_envelope = envelopes .iter() .find(|entry| { entry.r#type == "epiphany.eyes.repo_model_claim_challenge" && entry.key == challenge.challenge_id }) .cloned() .ok_or_else(|| anyhow!("claim repair challenge envelope is missing"))?; let packet_envelope = envelopes .iter() .find(|entry| entry.r#type == EYES_EVIDENCE_PACKET_TYPE && entry.key == packet.packet_id) .cloned() .ok_or_else(|| anyhow!("claim repair packet envelope is missing"))?; let original_admission_envelope = envelopes .iter() .find(|entry| { entry.r#type == REPO_MODEL_ADMISSION_RECEIPT_TYPE && entry.key == original_admission.receipt_id }) .cloned() .ok_or_else(|| anyhow!("claim repair original admission envelope is missing"))?; let current_admission_envelope = envelopes .iter() .find(|entry| { entry.r#type == REPO_MODEL_ADMISSION_RECEIPT_TYPE && entry.key == receipts[0].receipt_id }) .cloned() .ok_or_else(|| anyhow!("claim repair current admission envelope is missing"))?; let identity_envelope = envelopes .iter() .find(|entry| entry.r#type == RUNTIME_IDENTITY_TYPE && entry.key == RUNTIME_IDENTITY_KEY) .cloned() .ok_or_else(|| anyhow!("claim repair identity envelope is missing"))?; let thread_envelope = envelopes .iter() .find(|entry| entry.r#type == THREAD_STATE_TYPE && entry.key == crate::THREAD_STATE_KEY) .cloned() .ok_or_else(|| anyhow!("claim repair thread envelope is missing"))?; let (request_envelope, _) = cache.prepare_entry(&request_id, &request)?; let mut expected = vec![ model_envelope.clone(), challenge_envelope.clone(), packet_envelope.clone(), original_admission_envelope.clone(), identity_envelope.clone(), thread_envelope.clone(), ]; let mut replacement = vec![ model_envelope, challenge_envelope, packet_envelope, original_admission_envelope, identity_envelope, thread_envelope, ]; if request.current_admission_receipt_id != request.original_admission_receipt_id { expected.push(current_admission_envelope.clone()); replacement.push(current_admission_envelope); } replacement.push(request_envelope); if !backing.compare_and_swap_batch(&expected, replacement)? { let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; return match reloaded.get::(&request_id)? { Some(existing) if existing == request => Ok(existing), Some(_) => Err(anyhow!("claim repair request immutable collision")), None => Err(anyhow!("claim repair request lost exact causal CAS")), }; } Ok(request) } pub(crate) fn validate_current_repo_model_claim_repair_request( cache: &CultCache, request: &RepoModelClaimRepairRequest, ) -> Result<()> { chrono::DateTime::parse_from_rfc3339(&request.requested_at) .map_err(|_| anyhow!("claim repair request timestamp must be RFC3339"))?; let entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("claim repair request requires canonical model"))?; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let challenge = cache .get::(&request.challenge_id)? .ok_or_else(|| anyhow!("claim repair request requires exact challenge"))?; validate_repo_model_claim_challenge_chain(cache, &model, &model_hash, &challenge, false)?; let packet = cache .get::(&challenge.eyes_evidence_packet_id)? .ok_or_else(|| anyhow!("claim repair request requires exact Eyes packet"))?; let original_admission = cache .get::(&challenge.admission_receipt_id)? .ok_or_else(|| anyhow!("claim repair request requires original challenge admission"))?; let identity = cache .get::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("claim repair request requires runtime identity"))?; let thread = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("claim repair request requires authoritative thread"))?; let claim = model .nodes .iter() .find(|node| node.id == challenge.target_claim_id) .ok_or_else(|| anyhow!("claim repair target is no longer present"))?; if format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(claim)?)) != challenge.target_claim_sha256 { return Err(anyhow!( "claim repair challenge is already resolved by a changed claim" )); } let receipts = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .collect::>(); if receipts.len() != 1 { return Err(anyhow!( "claim repair request requires unique current admission receipt" )); } let mut affected_frontier = model .frontier .iter() .filter(|item| item.target_claim_ids.contains(&challenge.target_claim_id)) .map(|item| { Ok(RepoModelClaimRepairFrontierRef { frontier_item_id: item.id.clone(), frontier_item_sha256: format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?) ), }) }) .collect::>>()?; affected_frontier.sort_by(|a, b| a.frontier_item_id.cmp(&b.frontier_item_id)); let expected = RepoModelClaimRepairRequest { schema_version: REPO_MODEL_CLAIM_REPAIR_REQUEST_SCHEMA_VERSION.into(), request_id: format!("repo-model-claim-repair-{}", challenge.challenge_id), challenge_id: challenge.challenge_id.clone(), challenge_sha256: format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&challenge)?)), eyes_evidence_packet_id: packet.packet_id.clone(), eyes_evidence_packet_sha256: challenge.eyes_evidence_packet_sha256.clone(), source_result_id: challenge.source_result_id.clone(), source_job_id: challenge.source_job_id.clone(), original_admission_receipt_id: original_admission.receipt_id.clone(), current_admission_receipt_id: receipts[0].receipt_id.clone(), model_revision: model.model_revision, model_hash, target_claim_id: challenge.target_claim_id.clone(), target_claim_sha256: challenge.target_claim_sha256.clone(), runtime_id: identity.runtime_id.clone(), thread_id: thread.thread_id.clone(), affected_frontier, requested_at: request.requested_at.clone(), contract: REPO_MODEL_CLAIM_REPAIR_REQUEST_CONTRACT.into(), }; if *request != expected { return Err(anyhow!( "claim repair request does not match the current canonical causal chain" )); } Ok(()) } fn validate_repo_frontier_plan_candidate_against_request( cache: &CultCache, candidate: &RepoFrontierPlanCandidate, request: &RepoFrontierPlanningRequest, ) -> Result<()> { if candidate.schema_version != REPO_FRONTIER_PLAN_CANDIDATE_SCHEMA_VERSION || candidate.contract != REPO_FRONTIER_PLANNING_CONTRACT || candidate.selected_fields_invalid() || candidate.planning_request_id != request.request_id || candidate.model_revision != request.model_revision || candidate.model_hash != request.model_hash || candidate.frontier_item_id != request.frontier_item_id || candidate.frontier_item_hash != request.frontier_item_hash { return Err(anyhow!( "frontier planning candidate substituted request identity or required cargo" )); } let expected_candidate_id = canonical_repo_frontier_plan_candidate_id(candidate)?; if candidate.candidate_id != expected_candidate_id { return Err(anyhow!("frontier planning candidate id is not canonical")); } let admission = cache .get::(&request.admission_receipt_id)? .ok_or_else(|| anyhow!("frontier planning candidate requires exact admission receipt"))?; if !crate::repo_model_admission_receipt_schema_supported( &admission.schema_version, &admission.contract, ) || admission.admitted_revision != request.model_revision || admission.admitted_hash != request.model_hash { return Err(anyhow!( "frontier planning candidate admission binding mismatch" )); } let entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("frontier planning candidate requires canonical model"))?; let model = entry.snapshot()?; if model.model_revision != request.model_revision || crate::memory_graph_model_hash(&model)? != request.model_hash { return Err(anyhow!("frontier planning candidate model is stale")); } let item = model .frontier .iter() .find(|item| item.id == request.frontier_item_id) .ok_or_else(|| anyhow!("frontier planning candidate frontier disappeared"))?; if format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)) != request.frontier_item_hash || item.source_scope != request.source_scope || !candidate.safe_paths.iter().all(|path| { request.source_scope.iter().any(|scope| { path == scope || path.starts_with(&format!("{}/", scope.trim_end_matches(['/', '\\']))) }) }) { return Err(anyhow!( "frontier planning candidate exceeds exact frontier authority" )); } Ok(()) } pub fn canonical_repo_frontier_plan_candidate_id( candidate: &RepoFrontierPlanCandidate, ) -> Result { let semantic_bytes = rmp_serde::to_vec_named(&( &candidate.planning_request_id, candidate.model_revision, &candidate.model_hash, &candidate.frontier_item_id, &candidate.frontier_item_hash, &candidate.safe_paths, &candidate.action, &candidate.command, &candidate.checks, &candidate.stop_conditions, &candidate.rollback_steps, &candidate.commit_message, &candidate.proposed_at, ))?; Ok(format!( "repo-frontier-plan-candidate-{:x}", Sha256::digest(semantic_bytes) )) } pub fn commit_repo_frontier_plan_decision( runtime_store: impl AsRef, mind_result_id: &str, ) -> Result { commit_repo_frontier_plan_decision_inner( runtime_store, FrontierPlanDecisionSource::MindWorker(mind_result_id), None, ) } enum FrontierPlanDecisionSource<'a> { MindWorker(&'a str), Operator(&'a crate::RepoFrontierPlanOperatorReview), } /// Read-only, bounded identities for candidates already routed to canonical /// Mind review. Invalid, stale, or terminal candidates are not projected. pub fn pending_repo_frontier_plan_reviews( runtime_store: impl AsRef, limit: usize, ) -> Result> { if limit == 0 || limit > 25 { return Err(anyhow!( "Mind review projection limit must be within 1..=25" )); } let mut cache = runtime_spine_cache(runtime_store.as_ref())?; cache.pull_all_backing_stores()?; let terminal = cache .get_all::()? .into_iter() .map(|receipt| receipt.planning_request_id) .collect::>(); let mut summaries = Vec::new(); for request in cache.get_all::()? { let Ok((planning, candidate)) = validate_repo_frontier_plan_mind_request(&cache, &request) else { continue; }; if terminal.contains(&planning.request_id) { continue; } summaries.push(crate::RepoFrontierPlanReviewSummary { mind_request_id: request.request_id, candidate_id: candidate.candidate_id, candidate_sha256: request.candidate_sha256, model_revision: planning.model_revision, model_hash: planning.model_hash, frontier_item_id: planning.frontier_item_id, requested_at: request.requested_at, }); } summaries.sort_by(|a, b| { a.requested_at .cmp(&b.requested_at) .then_with(|| a.mind_request_id.cmp(&b.mind_request_id)) }); summaries.truncate(limit); Ok(summaries) } /// Canonical Mind commit path for an authenticated operator's exact review /// request. The operator selects a disposition; Mind revalidates the complete /// immutable candidate and current model before performing the same atomic /// terminal transition used by a Mind worker. pub fn commit_operator_repo_frontier_plan_review( runtime_store: impl AsRef, review: &crate::RepoFrontierPlanOperatorReview, ) -> Result { commit_repo_frontier_plan_decision_inner( runtime_store, FrontierPlanDecisionSource::Operator(review), None, ) } /// Classifies only operator-visible precondition refusal. Store corruption, /// decoding failure, and I/O remain errors and must never be fossilized as a /// terminal Refused command result. pub fn operator_repo_frontier_plan_review_is_current( runtime_store: impl AsRef, review: &crate::RepoFrontierPlanOperatorReview, ) -> Result { let mut cache = runtime_spine_cache(runtime_store.as_ref())?; cache.pull_all_backing_stores()?; let Some(request) = cache.get::(&review.mind_request_id)? else { return Ok(false); }; let (planning, candidate) = validate_repo_frontier_plan_mind_request_identity(&cache, &request)?; if review.candidate_id != candidate.candidate_id || review.candidate_sha256 != request.candidate_sha256 || review.expected_model_revision != planning.model_revision || review.expected_model_hash != planning.model_hash { return Ok(false); } let terminal = cache .get_all::()? .into_iter() .filter(|receipt| receipt.planning_request_id == planning.request_id) .collect::>(); if !terminal.is_empty() { if terminal.len() != 1 { return Err(anyhow!( "Mind review candidate has multiple terminal decisions" )); } let receipt = &terminal[0]; return Ok(receipt.decision == review.decision && receipt.candidate_id == review.candidate_id && receipt.candidate_sha256 == review.candidate_sha256 && receipt.model_revision == review.expected_model_revision && receipt.model_hash == review.expected_model_hash && receipt.decision_source.as_ref() == Some( &crate::RepoFrontierPlanDecisionSource::AuthenticatedOperatorReview { command_id: review.command_id.clone(), admission_id: review.admission_id.clone(), packet_sha256: review.packet_sha256.clone(), source_actor_id: review.source_actor_id.clone(), }, )); } let current = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("operator Mind review requires canonical RepoModel"))? .snapshot()?; if current.model_revision != planning.model_revision || crate::memory_graph_model_hash(¤t)? != planning.model_hash { return Ok(false); } validate_repo_frontier_plan_candidate_against_request(&cache, &candidate, &planning)?; Ok(true) } fn commit_repo_frontier_plan_decision_inner( runtime_store: impl AsRef, source: FrontierPlanDecisionSource<'_>, pre_cas: Option<&(dyn Fn() + Sync)>, ) -> Result { let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; let (mind_request_id, decision, rationale, decided_at, decision_source) = match source { FrontierPlanDecisionSource::MindWorker(mind_result_id) => { validate_non_empty(mind_result_id, "frontier plan Mind result id")?; let results = cache .get_all::()? .into_iter() .filter(|result| result.result_id == mind_result_id) .collect::>(); if results.len() != 1 { return Err(anyhow!( "frontier plan decision requires exactly one immutable Mind result" )); } let mind_result = &results[0]; let mind_request_id = mind_result .frontier_plan_mind_request_id .clone() .ok_or_else(|| anyhow!("frontier plan decision Mind result lacks request echo"))?; let typed = mind_result.frontier_plan_mind_decision()?.ok_or_else(|| { anyhow!("frontier plan decision requires typed immutable Mind decision") })?; ( mind_request_id, typed.decision, typed.rationale, typed.decided_at, crate::RepoFrontierPlanDecisionSource::MindWorker { result_id: mind_result.result_id.clone(), job_id: mind_result.job_id.clone(), }, ) } FrontierPlanDecisionSource::Operator(review) => { validate_non_empty(&review.command_id, "operator review command id")?; validate_non_empty(&review.admission_id, "operator review admission id")?; validate_non_empty(&review.packet_sha256, "operator review packet digest")?; validate_non_empty(&review.source_actor_id, "operator review actor id")?; chrono::DateTime::parse_from_rfc3339(&review.decided_at) .map_err(|_| anyhow!("operator review timestamp must be RFC3339"))?; ( review.mind_request_id.clone(), review.decision, format!("Authenticated operator requested {:?}.", review.decision).to_lowercase(), review.decided_at.clone(), crate::RepoFrontierPlanDecisionSource::AuthenticatedOperatorReview { command_id: review.command_id.clone(), admission_id: review.admission_id.clone(), packet_sha256: review.packet_sha256.clone(), source_actor_id: review.source_actor_id.clone(), }, ) } }; let mind_request = cache .get::(&mind_request_id)? .ok_or_else(|| anyhow!("frontier plan decision requires typed Mind request"))?; let (request, candidate) = validate_repo_frontier_plan_mind_request_identity(&cache, &mind_request)?; if let FrontierPlanDecisionSource::Operator(review) = source { if review.candidate_id != candidate.candidate_id || review.candidate_sha256 != mind_request.candidate_sha256 || review.expected_model_revision != request.model_revision || review.expected_model_hash != request.model_hash { return Err(anyhow!( "operator review does not exactly bind current Mind candidate" )); } } let rationale = rationale.as_str(); let decided_at = decided_at.as_str(); let result_id = mind_request.imagination_result_id.as_str(); let source_results = cache .get_all::()? .into_iter() .filter(|r| r.result_id == result_id) .collect::>(); if source_results.len() != 1 { return Err(anyhow!("Mind decision lost its exact Imagination source")); } let result = &source_results[0]; let request_id = result .frontier_planning_request_id .as_deref() .ok_or_else(|| anyhow!("frontier plan decision result lacks its planning request echo"))?; if request.request_id != request_id { return Err(anyhow!("Mind request planning echo mismatch")); } let candidate_bytes = rmp_serde::to_vec_named(&candidate)?; let candidate_sha256 = format!("{:x}", Sha256::digest(&candidate_bytes)); let decision_id = format!( "repo-frontier-plan-decision-{:x}", Sha256::digest(request.request_id.as_bytes()) ); let existing_for_request = cache .get_all::()? .into_iter() .filter(|receipt| receipt.planning_request_id == request.request_id) .collect::>(); if !existing_for_request.is_empty() { if existing_for_request.len() != 1 { return Err(anyhow!( "frontier planning request has multiple terminal Mind decisions" )); } let existing = &existing_for_request[0]; let expected_admission_id = if decision == RepoFrontierPlanDecision::Adopt { format!("repo-model-admission-{decision_id}") } else { String::new() }; if ![ REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION, crate::LEGACY_REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION, ] .contains(&existing.schema_version.as_str()) || existing.contract != REPO_FRONTIER_PLAN_DECISION_CONTRACT || existing.decision_id != decision_id || (existing.schema_version == REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION && (existing.decision_source.as_ref() != Some(&decision_source) || existing.legacy_mind_worker_result_id.is_some() || existing.legacy_mind_worker_job_id.is_some())) || (existing.schema_version == crate::LEGACY_REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION && !matches!( &decision_source, crate::RepoFrontierPlanDecisionSource::MindWorker { result_id, job_id } if existing.decision_source.is_none() && existing.legacy_mind_worker_result_id.as_deref() == Some(result_id.as_str()) && existing.legacy_mind_worker_job_id.as_deref() == Some(job_id.as_str()) )) || existing.candidate_id != candidate.candidate_id || existing.candidate_sha256 != candidate_sha256 || existing.model_revision != request.model_revision || existing.model_hash != request.model_hash || existing.frontier_item_id != request.frontier_item_id || existing.frontier_item_hash != request.frontier_item_hash || existing.decision != decision || existing.rationale != rationale || existing.decided_at != decided_at || existing.model_admission_receipt_id != expected_admission_id { return Err(anyhow!("frontier plan decision identity collision")); } if decision == RepoFrontierPlanDecision::Adopt { let admission = cache .get::(&expected_admission_id)? .ok_or_else(|| anyhow!("Adopt retry lost its model admission receipt"))?; let expected_review_id = format!("repo-model-review-{decision_id}"); let expected_patch_id = format!("repo-frontier-plan-adopt-patch-{}", request.request_id); let review = cache .get::(&expected_review_id)? .ok_or_else(|| anyhow!("Adopt retry lost its Mind admission review"))?; let expected_admission_source = if existing.schema_version == crate::LEGACY_REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION { None } else { Some(repo_model_admission_source(&decision_source, &decision_id)) }; if !crate::repo_model_admission_receipt_schema_supported( &admission.schema_version, &admission.contract, ) || admission.receipt_id != expected_admission_id || admission.review_id != expected_review_id || admission.result_id.as_deref() != decision_source_reference(&decision_source) || admission.patch_id != expected_patch_id || admission.patch_sha256.trim().is_empty() || admission.previous_revision != request.model_revision || admission.previous_hash != request.model_hash || admission.admitted_revision != request.model_revision + 1 || admission.admitted_hash.trim().is_empty() || admission.admitted_at != decided_at || admission.purpose != (crate::RepoModelPatchPurpose::AdoptFrontierPlan { planning_request_id: request.request_id.clone(), result_id: result.result_id.clone(), candidate_id: candidate.candidate_id.clone(), }) || admission.frontier_route_id != "" || admission.verification_request_id != "" || admission.soul_verdict_receipt_id != "" || admission.frontier_modeling_request_id != "" || admission.proposal_modeling_request_id != "" || admission.claim_repair_request_id != "" || admission.frontier_plan_decision_id != decision_id || admission.admission_source != expected_admission_source || !crate::repo_model_admission_review_schema_supported( &review.schema_version, &review.contract, ) || review.review_id != expected_review_id || review.result_id.as_deref() != decision_source_reference(&decision_source) || review.job_id.as_deref() != decision_source_job_reference(&decision_source) || review.patch_id != expected_patch_id || review.patch_sha256 != admission.patch_sha256 || review.base_revision != request.model_revision || review.base_hash != request.model_hash || review.decision != MindGatewayDecision::Accept || review.evidence_ids != vec![ request.request_id.clone(), result.result_id.clone(), decision_evidence_reference(&decision_source, &decision_id).to_string(), ] || review.reviewed_at != decided_at || review.admission_source != expected_admission_source { return Err(anyhow!("Adopt retry model admission chain mismatch")); } require_modeling_projection_obligation_for_commit( &cache, &admission.receipt_id, admission.admitted_revision, &admission.admitted_hash, &admission.admitted_at, )?; } return Ok(existing.clone()); } // Exact retry through the immutable result validator also replays request, // launch binding, launch bytes, runtime/thread, model, admission, frontier, // and candidate scope immediately before Mind decides. if let FrontierPlanDecisionSource::MindWorker(mind_result_id) = source { let mind_result = cache .get_all::()? .into_iter() .find(|result| result.result_id == mind_result_id) .ok_or_else(|| anyhow!("frontier plan Mind result disappeared"))?; put_runtime_role_worker_result(runtime_store, &mind_result)?; } put_runtime_role_worker_result(runtime_store, result)?; validate_current_repo_frontier_planning_request(&cache, &request)?; validate_repo_frontier_plan_candidate_against_request(&cache, &candidate, &request)?; let mut receipt = RepoFrontierPlanDecisionReceipt { schema_version: REPO_FRONTIER_PLAN_DECISION_RECEIPT_SCHEMA_VERSION.into(), decision_id: decision_id.clone(), planning_request_id: request.request_id.clone(), legacy_mind_worker_result_id: None, legacy_mind_worker_job_id: None, candidate_id: candidate.candidate_id.clone(), candidate_sha256: candidate_sha256.clone(), model_revision: request.model_revision, model_hash: request.model_hash.clone(), frontier_item_id: request.frontier_item_id.clone(), frontier_item_hash: request.frontier_item_hash.clone(), decision, rationale: rationale.to_string(), decided_at: decided_at.to_string(), model_admission_receipt_id: String::new(), contract: REPO_FRONTIER_PLAN_DECISION_CONTRACT.into(), decision_source: Some(decision_source.clone()), }; let backing = SingleFileMessagePackBackingStore::new(runtime_store); let current_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("frontier plan decision requires canonical RepoModel"))?; let current_entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(¤t_envelope.payload)?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; if current.model_revision != request.model_revision || crate::memory_graph_model_hash(¤t)? != request.model_hash { return Err(anyhow!( "frontier plan decision model changed before commit" )); } let mut companions = Vec::new(); let replacement = if decision == RepoFrontierPlanDecision::Adopt { let adopted_plan = crate::RepoFrontierAdoptedPlan { planning_request_id: request.request_id.clone(), result_id: result.result_id.clone(), job_id: result.job_id.clone(), candidate_id: candidate.candidate_id.clone(), candidate_sha256: candidate_sha256.clone(), safe_paths: candidate.safe_paths.clone(), action: candidate.action.clone(), command: candidate.command.clone(), checks: candidate.checks.clone(), stop_conditions: candidate.stop_conditions.clone(), rollback_steps: candidate.rollback_steps.clone(), commit_message: candidate.commit_message.clone(), }; let patch = crate::RepoModelPatch { patch_id: format!("repo-frontier-plan-adopt-patch-{}", request.request_id), base_revision: request.model_revision, base_hash: request.model_hash.clone(), applied_at: decided_at.to_string(), purpose: crate::RepoModelPatchPurpose::AdoptFrontierPlan { planning_request_id: request.request_id.clone(), result_id: result.result_id.clone(), candidate_id: candidate.candidate_id.clone(), }, operations: vec![crate::RepoModelPatchOperation::AdoptFrontierPlan { frontier_item_id: request.frontier_item_id.clone(), expected_frontier_item_hash: request.frontier_item_hash.clone(), adopted_plan, }], }; let patch_bytes = rmp_serde::to_vec_named(&patch)?; let patch_sha256 = format!("{:x}", Sha256::digest(&patch_bytes)); let next = crate::derive_repo_model_patch(¤t, &patch)?; let next_entry = crate::EpiphanyMemoryGraphEntry::from_snapshot(&next)?; let review_id = format!("repo-model-review-{decision_id}"); let admission_id = format!("repo-model-admission-{decision_id}"); let review = RepoModelAdmissionReview { schema_version: REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION.into(), review_id: review_id.clone(), result_id: decision_source_reference(&decision_source).map(str::to_string), job_id: decision_source_job_reference(&decision_source).map(str::to_string), patch_id: patch.patch_id.clone(), patch_sha256: patch_sha256.clone(), base_revision: request.model_revision, base_hash: request.model_hash.clone(), decision: MindGatewayDecision::Accept, evidence_ids: vec![ request.request_id.clone(), result.result_id.clone(), decision_evidence_reference(&decision_source, &decision_id).to_string(), ], reviewed_at: decided_at.to_string(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), repository_body_observation_basis: None, admission_source: Some(repo_model_admission_source(&decision_source, &decision_id)), }; let admission = RepoModelAdmissionReceipt { schema_version: REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION.into(), receipt_id: admission_id.clone(), review_id, result_id: decision_source_reference(&decision_source).map(str::to_string), patch_id: patch.patch_id, patch_sha256, previous_revision: request.model_revision, previous_hash: request.model_hash.clone(), admitted_revision: next.model_revision, admitted_hash: next.model_hash.clone(), admitted_at: decided_at.to_string(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), purpose: patch.purpose, frontier_route_id: String::new(), verification_request_id: String::new(), soul_verdict_receipt_id: String::new(), frontier_modeling_request_id: String::new(), proposal_modeling_request_id: String::new(), claim_repair_request_id: String::new(), frontier_plan_decision_id: decision_id.clone(), repository_body_observation_basis: None, admission_source: Some(repo_model_admission_source(&decision_source, &decision_id)), }; let obligation = modeling_projection_obligation( &cache, &next, &admission.receipt_id, &admission.admitted_at, )?; receipt.model_admission_receipt_id = admission_id; companions.push(cache.prepare_entry(&review.review_id, &review)?.0); companions.push(cache.prepare_entry(&admission.receipt_id, &admission)?.0); companions.push( cache .prepare_entry(&obligation.obligation_id, &obligation)? .0, ); cache.prepare_entry(crate::MEMORY_GRAPH_KEY, &next_entry)?.0 } else { current_envelope.clone() }; companions.push(cache.prepare_entry(&receipt.decision_id, &receipt)?.0); let mut writes = vec![replacement]; writes.extend(companions); if let Some(pre_cas) = pre_cas { pre_cas(); } if !backing.compare_and_swap_batch(&[current_envelope], writes)? { // A concurrent exact retry may have installed the same immutable // decision and admission chain. Reload through the public validator: // it returns that winner only when every identity field matches, while // a competing decision or unrelated model change remains an error. return match source { FrontierPlanDecisionSource::MindWorker(mind_result_id) => { commit_repo_frontier_plan_decision(runtime_store, mind_result_id) } FrontierPlanDecisionSource::Operator(review) => { commit_operator_repo_frontier_plan_review(runtime_store, review) } }; } Ok(receipt) } fn decision_source_reference(source: &crate::RepoFrontierPlanDecisionSource) -> Option<&str> { match source { crate::RepoFrontierPlanDecisionSource::MindWorker { result_id, .. } => Some(result_id), crate::RepoFrontierPlanDecisionSource::AuthenticatedOperatorReview { .. } => None, } } fn decision_source_job_reference(source: &crate::RepoFrontierPlanDecisionSource) -> Option<&str> { match source { crate::RepoFrontierPlanDecisionSource::MindWorker { job_id, .. } => Some(job_id), crate::RepoFrontierPlanDecisionSource::AuthenticatedOperatorReview { .. } => None, } } fn decision_evidence_reference<'a>( source: &'a crate::RepoFrontierPlanDecisionSource, decision_id: &'a str, ) -> &'a str { match source { crate::RepoFrontierPlanDecisionSource::MindWorker { result_id, .. } => result_id, crate::RepoFrontierPlanDecisionSource::AuthenticatedOperatorReview { .. } => decision_id, } } fn repo_model_admission_source( source: &crate::RepoFrontierPlanDecisionSource, decision_id: &str, ) -> crate::RepoModelAdmissionSource { match source { crate::RepoFrontierPlanDecisionSource::MindWorker { result_id, job_id } => { crate::RepoModelAdmissionSource::WorkerResult { result_id: result_id.clone(), job_id: job_id.clone(), } } crate::RepoFrontierPlanDecisionSource::AuthenticatedOperatorReview { .. } => { crate::RepoModelAdmissionSource::FrontierPlanDecision { decision_id: decision_id.to_string(), } } } } #[cfg(test)] pub(crate) fn commit_repo_frontier_plan_decision_with_pre_cas( runtime_store: impl AsRef, mind_result_id: &str, pre_cas: &(dyn Fn() + Sync), ) -> Result { commit_repo_frontier_plan_decision_inner( runtime_store, FrontierPlanDecisionSource::MindWorker(mind_result_id), Some(pre_cas), ) } impl RepoFrontierPlanCandidate { fn selected_fields_invalid(&self) -> bool { self.candidate_id.trim().is_empty() || self.safe_paths.is_empty() || !safe_sorted_unique_paths(&self.safe_paths) || self.action.trim().is_empty() || self.command.trim().is_empty() || self.checks.is_empty() || self.checks.iter().any(|v| v.trim().is_empty()) || self.stop_conditions.is_empty() || self.stop_conditions.iter().any(|v| v.trim().is_empty()) || self.rollback_steps.is_empty() || self.rollback_steps.iter().any(|v| v.trim().is_empty()) || self.commit_message.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&self.proposed_at).is_err() } } pub fn select_and_commit_repo_frontier_route( runtime_store: impl AsRef, at: &str, ) -> Result { chrono::DateTime::parse_from_rfc3339(at) .map_err(|_| anyhow!("repo frontier route timestamp must be RFC3339"))?; let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let backing = SingleFileMessagePackBackingStore::new(runtime_store); let current_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("repo frontier routing requires the canonical runtime model"))?; let current_entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(¤t_envelope.payload)?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; let current_hash = crate::memory_graph_model_hash(¤t)?; let receipts = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == current.model_revision && receipt.admitted_hash == current_hash }) .collect::>(); if receipts.len() != 1 { return Err(anyhow!( "repo frontier routing requires exactly one admission receipt for the current model" )); } let receipt = &receipts[0]; let challenges = current_repo_model_claim_challenges(&cache, ¤t, ¤t_hash)?; let item = actionable_hands_frontier_item(¤t, &challenges) .ok_or_else(|| anyhow!("current repo model has no eligible Hands frontier route"))?; if !safe_sorted_unique_paths(&item.source_scope) || item.source_scope.is_empty() { return Err(anyhow!( "Hands frontier route requires safe sorted source scope" )); } let item_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)); let route_seed = format!("{}:{}:{}", current_hash, item.id, item_hash); let route_id = format!( "repo-frontier-route-{:x}", Sha256::digest(route_seed.as_bytes()) ); let route = RepoFrontierRoute { schema_version: REPO_FRONTIER_ROUTE_SCHEMA_VERSION.to_string(), route_id: route_id.clone(), next_organ: RepoFrontierNextOrgan::Hands, model_revision: current.model_revision, model_hash: current_hash, admission_receipt_id: receipt.receipt_id.clone(), frontier_item_id: item.id.clone(), frontier_item_hash: item_hash, migration_body: item.migration_body.clone(), question: item.question.clone(), gap: item.gap.clone(), target_claim_ids: item.target_claim_ids.clone(), source_scope: item .adopted_plan .as_ref() .map(|plan| plan.safe_paths.clone()) .unwrap_or_else(|| item.source_scope.clone()), adopted_plan: item.adopted_plan.clone(), selected_at: at.to_string(), contract: REPO_FRONTIER_ROUTE_CONTRACT.to_string(), }; if let Some(existing) = cache.get::(&route_id)? { let mut retry = route.clone(); retry.selected_at = existing.selected_at.clone(); return if existing == retry { Ok(existing) } else { Err(anyhow!( "repo frontier route deterministic identity collision" )) }; } let (route_envelope, _) = cache.prepare_entry(&route_id, &route)?; if !backing.compare_and_swap_batch( &[current_envelope.clone()], vec![current_envelope, route_envelope], )? { return Err(anyhow!( "repo frontier route lost current-model CAS or companion collision" )); } Ok(route) } fn actionable_hands_frontier_item<'a>( model: &'a crate::EpiphanyMemoryGraphSnapshot, challenges: &[RepoModelClaimChallenge], ) -> Option<&'a crate::RepoFrontierItem> { actionable_frontier_item_for_organ(model, challenges, "Hands", true) } fn actionable_frontier_item_for_organ<'a>( model: &'a crate::EpiphanyMemoryGraphSnapshot, challenges: &[RepoModelClaimChallenge], organ: &str, require_unchallenged_targets: bool, ) -> Option<&'a crate::RepoFrontierItem> { let terminal = |status: crate::RepoFrontierStatus| { matches!( status, crate::RepoFrontierStatus::Resolved | crate::RepoFrontierStatus::Retired | crate::RepoFrontierStatus::Superseded ) }; model.frontier.iter().find(|item| { item.status == crate::RepoFrontierStatus::Active && item.recommended_next_organ == organ && !item.source_scope.is_empty() && safe_sorted_unique_paths(&item.source_scope) && (!require_unchallenged_targets || frontier_target_claims_unchallenged(item, challenges)) && item.dependency_item_ids.iter().all(|dependency_id| { model .frontier .iter() .find(|candidate| candidate.id == *dependency_id) .is_some_and(|dependency| terminal(dependency.status)) }) }) } /// Read-only Self signal. It is true only when the canonical runtime model is /// admitted exactly once and contains an item the route committer can hand to /// Hands. Status projection must use this instead of assuming that a clear /// CRRC lane implies implementation authority. pub fn runtime_has_actionable_hands_frontier(runtime_store: impl AsRef) -> Result { runtime_has_actionable_frontier_for_organ(runtime_store, "Hands") } /// Read-only Self signal for source gathering. It is true only when the /// canonical runtime model is admitted exactly once and contains an Active, /// dependency-ready Eyes frontier item. pub fn runtime_has_actionable_eyes_frontier(runtime_store: impl AsRef) -> Result { runtime_has_actionable_frontier_for_organ(runtime_store, "Eyes") } /// Read-only Self signal for proposal planning. It uses the same eligibility /// predicate as the planning-request committer, including unchallenged target /// claims, so status cannot advertise authority that the commit path rejects. pub fn runtime_has_actionable_imagination_frontier( runtime_store: impl AsRef, ) -> Result { let eligibility = runtime_repo_frontier_planning_eligibility(runtime_store)?; Ok(eligibility.current_admission_count == 1 && eligibility .candidates .iter() .any(|candidate| candidate.eligible)) } /// Read-only Self signal explaining the exact canonical blockers on every /// active Imagination frontier. It derives from the same admitted RepoModel, /// current claim-challenge set, source-scope predicate, and dependency rule as /// planning selection; it neither creates nor repairs authority. pub fn runtime_repo_frontier_planning_eligibility( runtime_store: impl AsRef, ) -> Result { let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let Some(entry) = cache.get::(crate::MEMORY_GRAPH_KEY)? else { return Ok(RepoFrontierPlanningEligibility { current_admission_count: 0, candidates: Vec::new(), }); }; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let admission_count = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .count(); let challenges = current_repo_model_claim_challenges(&cache, &model, &model_hash)?; let terminal = |status: crate::RepoFrontierStatus| { matches!( status, crate::RepoFrontierStatus::Resolved | crate::RepoFrontierStatus::Retired | crate::RepoFrontierStatus::Superseded ) }; let mut candidates = model .frontier .iter() .filter(|item| { matches!( item.status, crate::RepoFrontierStatus::Active | crate::RepoFrontierStatus::Proposed ) && item .recommended_next_organ .eq_ignore_ascii_case("Imagination") }) .map(|item| { let status_valid = item.status == crate::RepoFrontierStatus::Active; let recommended_next_organ_valid = item.recommended_next_organ == "Imagination"; let source_scope_valid = !item.source_scope.is_empty() && safe_sorted_unique_paths(&item.source_scope); let mut challenged_target_claim_ids = challenges .iter() .filter(|challenge| item.target_claim_ids.contains(&challenge.target_claim_id)) .map(|challenge| challenge.target_claim_id.clone()) .collect::>(); challenged_target_claim_ids.sort(); challenged_target_claim_ids.dedup(); let mut unresolved_dependency_item_ids = item .dependency_item_ids .iter() .filter(|dependency_id| { !model .frontier .iter() .find(|candidate| candidate.id.as_str() == dependency_id.as_str()) .is_some_and(|dependency| terminal(dependency.status)) }) .cloned() .collect::>(); unresolved_dependency_item_ids.sort(); unresolved_dependency_item_ids.dedup(); RepoFrontierPlanningCandidateEligibility { frontier_item_id: item.id.clone(), eligible: admission_count == 1 && status_valid && recommended_next_organ_valid && source_scope_valid && challenged_target_claim_ids.is_empty() && unresolved_dependency_item_ids.is_empty(), status_valid, recommended_next_organ_valid, source_scope_valid, challenged_target_claim_ids, unresolved_dependency_item_ids, } }) .collect::>(); candidates.sort_by(|a, b| a.frontier_item_id.cmp(&b.frontier_item_id)); Ok(RepoFrontierPlanningEligibility { current_admission_count: admission_count, candidates, }) } /// Returns the oldest selected proposal that has not yet been claimed by a /// Modeling launch. Selection is already explicit Self authority; several /// Imagination options may therefore form a queue without asking this /// projection to prefer one proposal over another. Stable request order owns /// scheduling only and prevents the CLI from becoming a second routing owner. pub fn runtime_pending_repo_frontier_proposal_modeling_request( runtime_store: impl AsRef, ) -> Result> { let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let launches = cache.get_all::()?; let mut pending = cache .get_all::()? .into_iter() .filter_map(|request| { if validate_repo_frontier_proposal_modeling_request(&request).is_err() || launches .iter() .any(|launch| launch.proposal_modeling_request_id == request.request_id) { None } else { Some(request) } }) .collect::>(); pending.sort_by(|a, b| { a.selected_at .cmp(&b.selected_at) .then_with(|| a.request_id.cmp(&b.request_id)) }); Ok(pending.into_iter().next()) } /// Read-only Self projection over the existing typed frontier-planning chain. /// It never creates a request or decision; each mutating stage remains owned by /// its established commit primitive. pub fn runtime_repo_frontier_planning_lifecycle( runtime_store: impl AsRef, ) -> Result { let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let empty = |stage| RepoFrontierPlanningLifecycle { stage, planning_request_id: None, imagination_job_id: None, imagination_result_id: None, mind_request_id: None, mind_job_id: None, mind_result_id: None, decision_id: None, }; let decisions = cache.get_all::()?; let mut active_requests = Vec::new(); let mut terminal_current_requests = Vec::new(); for request in cache.get_all::()? { if validate_current_repo_frontier_planning_request(&cache, &request).is_ok() { if let Some(decision) = decisions .iter() .find(|decision| decision.planning_request_id == request.request_id) { terminal_current_requests.push((request, decision)); } else { active_requests.push(request); } } } active_requests.sort_by(|a, b| { a.requested_at .cmp(&b.requested_at) .then_with(|| a.request_id.cmp(&b.request_id)) }); if active_requests.len() > 1 { return Err(anyhow!( "Self found multiple nonterminal current frontier planning requests" )); } if terminal_current_requests.len() > 1 { return Err(anyhow!( "Self found multiple terminal decisions for current frontier planning authority" )); } let Some(request) = active_requests.pop() else { if let Some((request, decision)) = terminal_current_requests.pop() { return Ok(RepoFrontierPlanningLifecycle { decision_id: Some(decision.decision_id.clone()), planning_request_id: Some(request.request_id), ..empty(RepoFrontierPlanningLifecycleStage::Terminal) }); } if runtime_has_actionable_imagination_frontier(runtime_store)? { return Ok(empty(RepoFrontierPlanningLifecycleStage::Ready)); } let latest_terminal = decisions.iter().max_by(|a, b| { a.decided_at .cmp(&b.decided_at) .then_with(|| a.decision_id.cmp(&b.decision_id)) }); return Ok(if let Some(decision) = latest_terminal { RepoFrontierPlanningLifecycle { decision_id: Some(decision.decision_id.clone()), planning_request_id: Some(decision.planning_request_id.clone()), ..empty(RepoFrontierPlanningLifecycleStage::Terminal) } } else { empty(RepoFrontierPlanningLifecycleStage::Unavailable) }); }; let mut lifecycle = RepoFrontierPlanningLifecycle { stage: RepoFrontierPlanningLifecycleStage::ImaginationLaunchReady, planning_request_id: Some(request.request_id.clone()), imagination_job_id: None, imagination_result_id: None, mind_request_id: None, mind_job_id: None, mind_result_id: None, decision_id: None, }; let mut imagination_launches = cache .get_all::()? .into_iter() .filter(|binding| binding.planning_request_id == request.request_id) .collect::>(); imagination_launches.sort_by_key(|binding| binding.attempt_ordinal); for (expected, binding) in imagination_launches.iter().enumerate() { if binding.attempt_ordinal != expected as u64 { return Err(anyhow!( "Self found noncontiguous frontier planning attempt identity" )); } } if let Some(binding) = imagination_launches.last() { lifecycle.imagination_job_id = Some(binding.job_id.clone()); } let imagination_results = cache .get_all::()? .into_iter() .filter(|result| lifecycle.imagination_job_id.as_deref() == Some(result.job_id.as_str())) .collect::>(); if imagination_results.len() > 1 { return Err(anyhow!( "Self found multiple immutable Imagination results for one planning request" )); } let Some(imagination_result) = imagination_results.first() else { if lifecycle.imagination_job_id.is_some() { lifecycle.stage = RepoFrontierPlanningLifecycleStage::ImaginationRunning; } return Ok(lifecycle); }; lifecycle.imagination_job_id = Some(imagination_result.job_id.clone()); lifecycle.imagination_result_id = Some(imagination_result.result_id.clone()); if imagination_result.frontier_planning_request_id.as_deref() != Some(request.request_id.as_str()) { if !imagination_result .role_id .eq_ignore_ascii_case("imagination") || imagination_result .item_error .as_deref() .is_none_or(str::is_empty) || imagination_result.frontier_plan_candidate_msgpack.is_some() { return Err(anyhow!( "Self found malformed typed frontier planning failure" )); } let reviewed = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("planning failure review requires thread state"))? .state()? .acceptance_receipts .into_iter() .filter(|receipt| { receipt.result_id == imagination_result.result_id && receipt.job_id == imagination_result.job_id && receipt.binding_id == EPIPHANY_IMAGINATION_ROLE_BINDING_ID && receipt.surface == "roleFailureReview" && receipt.role_id == "imagination" && receipt.status == "superseded" }) .count(); lifecycle.stage = if reviewed == 1 { RepoFrontierPlanningLifecycleStage::ImaginationLaunchReady } else if reviewed == 0 { RepoFrontierPlanningLifecycleStage::ImaginationFailed } else { return Err(anyhow!( "Self found conflicting frontier planning failure reviews" )); }; return Ok(lifecycle); } let mind_requests = cache .get_all::()? .into_iter() .filter(|mind| mind.imagination_result_id == imagination_result.result_id) .collect::>(); if mind_requests.len() > 1 { return Err(anyhow!( "Self found multiple Mind requests for one Imagination result" )); } let Some(mind_request) = mind_requests.first() else { lifecycle.stage = RepoFrontierPlanningLifecycleStage::ImaginationResultReady; return Ok(lifecycle); }; validate_repo_frontier_plan_mind_request(&cache, mind_request)?; lifecycle.mind_request_id = Some(mind_request.request_id.clone()); lifecycle.stage = RepoFrontierPlanningLifecycleStage::MindLaunchReady; let mut mind_launches = cache .get_all::()? .into_iter() .filter(|binding| binding.mind_request_id == mind_request.request_id) .collect::>(); mind_launches.sort_by_key(|binding| binding.attempt_ordinal); for (expected, binding) in mind_launches.iter().enumerate() { if binding.attempt_ordinal != expected as u64 { return Err(anyhow!("Self found noncontiguous Mind attempt identity")); } } if let Some(binding) = mind_launches.last() { lifecycle.mind_job_id = Some(binding.job_id.clone()); } let mind_results = cache .get_all::()? .into_iter() .filter(|result| lifecycle.mind_job_id.as_deref() == Some(result.job_id.as_str())) .collect::>(); if mind_results.len() > 1 { return Err(anyhow!( "Self found multiple immutable Mind results for one planning request" )); } let Some(mind_result) = mind_results.first() else { if lifecycle.mind_job_id.is_some() { lifecycle.stage = RepoFrontierPlanningLifecycleStage::MindRunning; } return Ok(lifecycle); }; lifecycle.mind_job_id = Some(mind_result.job_id.clone()); lifecycle.mind_result_id = Some(mind_result.result_id.clone()); if mind_result.frontier_plan_mind_request_id.as_deref() != Some(mind_request.request_id.as_str()) { if !mind_result .role_id .eq_ignore_ascii_case("mindAdmissionReview") || mind_result.item_error.as_deref().is_none_or(str::is_empty) || mind_result.frontier_plan_mind_decision_msgpack.is_some() { return Err(anyhow!("Self found malformed typed Mind failure")); } let reviewed = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("Mind failure review requires thread state"))? .state()? .acceptance_receipts .into_iter() .filter(|receipt| { receipt.result_id == mind_result.result_id && receipt.job_id == mind_result.job_id && receipt.binding_id == EPIPHANY_MIND_ROLE_BINDING_ID && receipt.surface == "roleFailureReview" && receipt.role_id == "mindAdmissionReview" && receipt.status == "superseded" }) .count(); lifecycle.stage = if reviewed == 1 { RepoFrontierPlanningLifecycleStage::MindLaunchReady } else if reviewed == 0 { RepoFrontierPlanningLifecycleStage::MindFailed } else { return Err(anyhow!("Self found conflicting Mind failure reviews")); }; return Ok(lifecycle); } lifecycle.stage = RepoFrontierPlanningLifecycleStage::MindResultReady; Ok(lifecycle) } fn runtime_has_actionable_frontier_for_organ( runtime_store: impl AsRef, organ: &str, ) -> Result { let runtime_store = runtime_store.as_ref(); let mut cache = runtime_spine_cache(runtime_store)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let Some(entry) = cache.get::(crate::MEMORY_GRAPH_KEY)? else { return Ok(false); }; crate::validate_memory_graph_entry(&entry)?; let model = entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let admission_count = cache .get_all::()? .into_iter() .filter(|receipt| { crate::repo_model_admission_receipt_schema_supported( &receipt.schema_version, &receipt.contract, ) && receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .count(); let challenges = current_repo_model_claim_challenges(&cache, &model, &model_hash)?; Ok(admission_count == 1 && actionable_frontier_item_for_organ(&model, &challenges, organ, organ == "Hands") .is_some()) } pub fn put_runtime_reorient_worker_result( store_path: impl AsRef, result: &EpiphanyRuntimeReorientWorkerResult, ) -> Result<()> { validate_non_empty(&result.job_id, "reorient worker result job id")?; validate_non_empty(&result.result_id, "reorient worker result id")?; validate_non_empty(&result.mode, "reorient worker result mode")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.put(&result.job_id, result)?; Ok(()) } pub fn runtime_reorient_worker_result( store_path: impl AsRef, job_id: &str, ) -> Result> { validate_non_empty(job_id, "reorient worker result job id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(job_id) } pub fn put_mind_gateway_review( store_path: impl AsRef, review: &MindGatewayReview, ) -> Result<()> { validate_non_empty(&review.gateway_id, "Mind gateway review id")?; validate_non_empty(&review.source_kind, "Mind gateway review source kind")?; validate_non_empty(&review.source_role_id, "Mind gateway review source role")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.put(&review.gateway_id, review)?; Ok(()) } pub fn runtime_mind_gateway_review( store_path: impl AsRef, gateway_id: &str, ) -> Result> { validate_non_empty(gateway_id, "Mind gateway review id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(gateway_id) } pub fn put_mind_state_commit_receipt( store_path: impl AsRef, receipt: &MindStateCommitReceipt, ) -> Result<()> { validate_non_empty(&receipt.receipt_id, "Mind state commit receipt id")?; validate_non_empty(&receipt.gateway_id, "Mind state commit gateway id")?; validate_non_empty(&receipt.source_kind, "Mind state commit source kind")?; validate_non_empty(&receipt.source_role_id, "Mind state commit source role")?; validate_non_empty(&receipt.committed_at, "Mind state commit timestamp")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.put(&receipt.receipt_id, receipt)?; Ok(()) } pub fn runtime_mind_state_commit_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Mind state commit receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn put_eyes_evidence_packet( store_path: impl AsRef, packet: &EyesEvidencePacket, ) -> Result<()> { validate_non_empty(&packet.packet_id, "Eyes evidence packet id")?; validate_non_empty( &packet.source_result_id, "Eyes evidence packet source result", )?; validate_non_empty(&packet.source_job_id, "Eyes evidence packet source job")?; validate_non_empty(&packet.source_role_id, "Eyes evidence packet source role")?; validate_non_empty(&packet.emitted_at, "Eyes evidence packet timestamp")?; if packet.evidence_ids.is_empty() { return Err(anyhow!("Eyes evidence packet must reference evidence ids")); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.put(&packet.packet_id, packet)?; Ok(()) } pub fn runtime_eyes_evidence_packet( store_path: impl AsRef, packet_id: &str, ) -> Result> { validate_non_empty(packet_id, "Eyes evidence packet id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(packet_id) } pub fn put_substrate_gate_repo_access_grant_receipt( store_path: impl AsRef, receipt: &SubstrateGateRepoAccessGrantReceipt, ) -> Result<()> { validate_non_empty( &receipt.receipt_id, "Substrate Gate access grant receipt id", )?; validate_non_empty( &receipt.runtime_job_id, "Substrate Gate access grant runtime job", )?; validate_non_empty(&receipt.binding_id, "Substrate Gate access grant binding")?; validate_non_empty(&receipt.role, "Substrate Gate access grant role")?; validate_non_empty( &receipt.authority_scope, "Substrate Gate access grant authority scope", )?; validate_non_empty(&receipt.granted_at, "Substrate Gate access grant timestamp")?; if receipt.granted_operations.is_empty() { return Err(anyhow!( "Substrate Gate access grant must name granted operations" )); } if receipt.schema_version != SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION || chrono::DateTime::parse_from_rfc3339(&receipt.granted_at).is_err() || receipt.contract.trim().is_empty() { return Err(anyhow!("invalid Substrate Gate access grant contract")); } let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let (envelope, _) = cache.prepare_entry(&receipt.receipt_id, receipt)?; let backing = SingleFileMessagePackBackingStore::new(store_path); if backing.compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&receipt.receipt_id)? { Some(existing) if existing == *receipt => Ok(()), _ => Err(anyhow!("Substrate Gate grant ids are immutable")), } } pub fn runtime_substrate_gate_repo_access_grant_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Substrate Gate access grant receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn put_hands_action_intent( store_path: impl AsRef, intent: &HandsActionIntent, ) -> Result<()> { validate_non_empty(&intent.intent_id, "Hands action intent id")?; validate_non_empty(&intent.runtime_job_id, "Hands action runtime job")?; validate_non_empty(&intent.binding_id, "Hands action binding")?; validate_non_empty(&intent.role, "Hands action role")?; validate_non_empty(&intent.authority_scope, "Hands action authority scope")?; validate_non_empty(&intent.requested_action, "Hands requested action")?; validate_non_empty( &intent.substrate_gate_grant_receipt_id, "Hands Substrate Gate grant receipt", )?; validate_non_empty(&intent.requested_at, "Hands action requested timestamp")?; if intent.requested_paths.is_empty() { return Err(anyhow!("Hands action intent must name requested paths")); } if intent.schema_version != HANDS_ACTION_INTENT_SCHEMA_VERSION || chrono::DateTime::parse_from_rfc3339(&intent.requested_at).is_err() || intent.contract.trim().is_empty() { return Err(anyhow!("invalid Hands action intent contract")); } let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let grant = cache .get::(&intent.substrate_gate_grant_receipt_id)? .ok_or_else(|| { anyhow!("Hands action intent requires its persisted Substrate Gate grant") })?; if grant.runtime_job_id != intent.runtime_job_id || grant.binding_id != intent.binding_id || grant.role != intent.role || grant.authority_scope != intent.authority_scope || !grant .granted_operations .iter() .any(|operation| operation == "read") || !intent.requested_paths.iter().all(|path| { grant.granted_paths.iter().any(|granted| { granted == "." || path == granted || path.starts_with(&format!("{}/", granted.trim_end_matches(['/', '\\']))) }) }) { return Err(anyhow!( "Hands action intent does not match its Substrate Gate grant scope" )); } let (envelope, _) = cache.prepare_entry(&intent.intent_id, intent)?; let backing = SingleFileMessagePackBackingStore::new(store_path); if backing.compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&intent.intent_id)? { Some(existing) if existing == *intent => Ok(()), _ => Err(anyhow!("Hands action intent ids are immutable")), } } pub fn runtime_hands_action_intent( store_path: impl AsRef, intent_id: &str, ) -> Result> { validate_non_empty(intent_id, "Hands action intent id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(intent_id) } pub fn put_hands_action_review( store_path: impl AsRef, review: &HandsActionReview, ) -> Result<()> { validate_non_empty(&review.review_id, "Hands action review id")?; validate_non_empty(&review.intent_id, "Hands action review intent")?; validate_non_empty(&review.decision, "Hands action review decision")?; validate_non_empty(&review.reviewed_at, "Hands action review timestamp")?; if review.allowed_operations.is_empty() { return Err(anyhow!("Hands action review must name allowed operations")); } if review.schema_version != HANDS_ACTION_REVIEW_SCHEMA_VERSION || chrono::DateTime::parse_from_rfc3339(&review.reviewed_at).is_err() || review.contract.trim().is_empty() { return Err(anyhow!("invalid Hands action review contract")); } let store_path = store_path.as_ref(); let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let (envelope, _) = cache.prepare_entry(&review.review_id, review)?; let backing = SingleFileMessagePackBackingStore::new(store_path); if backing.compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&review.review_id)? { Some(existing) if existing == *review => Ok(()), _ => Err(anyhow!("Hands action review ids are immutable")), } } pub fn runtime_hands_action_review( store_path: impl AsRef, review_id: &str, ) -> Result> { validate_non_empty(review_id, "Hands action review id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(review_id) } fn validate_repo_frontier_hands_authority_chain( cache: &CultCache, authority: &RepoFrontierHandsAuthority, ) -> Result<()> { let route = cache .get::(&authority.route_id)? .ok_or_else(|| anyhow!("Hands authority requires its persisted route"))?; let current_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("Hands authority requires the current model"))?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; let current_item = current .frontier .iter() .find(|item| item.id == route.frontier_item_id) .ok_or_else(|| anyhow!("Hands authority lost its model frontier"))?; let intent = cache .get::(&authority.hands_intent_id)? .ok_or_else(|| anyhow!("Hands authority requires its persisted intent"))?; let review = cache .get::(&authority.hands_review_id)? .ok_or_else(|| anyhow!("Hands authority requires its persisted review"))?; let grant = cache .get::(&authority.substrate_grant_receipt_id)? .ok_or_else(|| anyhow!("Hands authority requires its persisted Substrate grant"))?; let within_scope = authority.requested_paths.iter().all(|path| { route.source_scope.iter().any(|scope| { path == scope || path.starts_with(&format!("{}/", scope.trim_end_matches(['/', '\\']))) }) }); let requested_operations: &[&str] = match intent.requested_action.as_str() { "patch" => &["patch"], "continueImplementation" => &["patch", "command", "commit"], _ => { return Err(anyhow!( "Hands authority names an unsupported requested action" )); } }; let adopted_plan_binding_is_exact = match route.adopted_plan.as_ref() { Some(plan) => { intent.frontier_route_id == route.route_id && intent.plan_candidate_sha256 == plan.candidate_sha256 && intent.plan_action == plan.action } None => { intent.frontier_route_id.is_empty() && intent.plan_candidate_sha256.is_empty() && intent.plan_action.is_empty() } }; if route.schema_version != REPO_FRONTIER_ROUTE_SCHEMA_VERSION || route.contract != REPO_FRONTIER_ROUTE_CONTRACT || intent.schema_version != HANDS_ACTION_INTENT_SCHEMA_VERSION || review.schema_version != HANDS_ACTION_REVIEW_SCHEMA_VERSION || grant.schema_version != SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION || intent.contract.trim().is_empty() || review.contract.trim().is_empty() || grant.contract.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&intent.requested_at).is_err() || chrono::DateTime::parse_from_rfc3339(&review.reviewed_at).is_err() || chrono::DateTime::parse_from_rfc3339(&grant.granted_at).is_err() || route.next_organ != RepoFrontierNextOrgan::Hands || authority.model_revision != route.model_revision || authority.model_hash != route.model_hash || authority.frontier_item_id != route.frontier_item_id || authority.frontier_item_hash != route.frontier_item_hash || current.model_revision != route.model_revision || crate::memory_graph_model_hash(¤t)? != route.model_hash || current_item.adopted_plan != route.adopted_plan || route .adopted_plan .as_ref() .is_some_and(|plan| route.source_scope != plan.safe_paths) || !adopted_plan_binding_is_exact || review.intent_id != intent.intent_id || review.decision != "approved" || !requested_operations.iter().all(|required| { review .allowed_operations .iter() .any(|operation| operation == required) }) || intent.substrate_gate_grant_receipt_id != grant.receipt_id || grant.runtime_job_id != intent.runtime_job_id || grant.binding_id != intent.binding_id || grant.role != intent.role || grant.authority_scope != intent.authority_scope || !requested_operations.iter().all(|required| { grant .granted_operations .iter() .any(|operation| operation == required) }) || authority.requested_paths != intent.requested_paths || authority.requested_paths != grant.granted_paths || !within_scope { return Err(anyhow!( "repo frontier Hands authority chain violates its full authority contract" )); } Ok(()) } pub fn put_repo_frontier_hands_authority( store_path: impl AsRef, authority: &RepoFrontierHandsAuthority, ) -> Result<()> { let store_path = store_path.as_ref(); if authority.schema_version != REPO_FRONTIER_HANDS_AUTHORITY_SCHEMA_VERSION || authority.contract != REPO_FRONTIER_HANDS_AUTHORITY_CONTRACT || chrono::DateTime::parse_from_rfc3339(&authority.granted_at).is_err() || !safe_sorted_unique_paths(&authority.requested_paths) || authority.requested_paths.is_empty() { return Err(anyhow!("invalid repo frontier Hands authority contract")); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; validate_repo_frontier_hands_authority_chain(&cache, authority)?; let route = cache .get::(&authority.route_id)? .ok_or_else(|| anyhow!("repo frontier Hands authority requires its persisted route"))?; let current_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("repo frontier Hands authority requires the current model"))?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; let intent = cache .get::(&authority.hands_intent_id)? .ok_or_else(|| anyhow!("repo frontier Hands authority requires its persisted intent"))?; let review = cache .get::(&authority.hands_review_id)? .ok_or_else(|| anyhow!("repo frontier Hands authority requires its persisted review"))?; let grant = cache .get::(&authority.substrate_grant_receipt_id)? .ok_or_else(|| { anyhow!("repo frontier Hands authority requires its persisted Substrate grant") })?; let within_scope = authority.requested_paths.iter().all(|path| { route.source_scope.iter().any(|scope| { path == scope || path.starts_with(&format!("{}/", scope.trim_end_matches(['/', '\\']))) }) }); if route.schema_version != REPO_FRONTIER_ROUTE_SCHEMA_VERSION || route.contract != REPO_FRONTIER_ROUTE_CONTRACT || route.next_organ != RepoFrontierNextOrgan::Hands || authority.route_id != route.route_id || authority.model_revision != route.model_revision || authority.model_hash != route.model_hash || authority.frontier_item_id != route.frontier_item_id || authority.frontier_item_hash != route.frontier_item_hash || current.model_revision != route.model_revision || crate::memory_graph_model_hash(¤t)? != route.model_hash || review.intent_id != intent.intent_id || review.decision != "approved" || intent.substrate_gate_grant_receipt_id != grant.receipt_id || grant.runtime_job_id != intent.runtime_job_id || grant.binding_id != intent.binding_id || grant.role != intent.role || grant.authority_scope != intent.authority_scope || authority.requested_paths != intent.requested_paths || authority.requested_paths != grant.granted_paths || !within_scope { return Err(anyhow!( "repo frontier Hands authority does not exactly bind route, model, intent, review, grant, and scope" )); } let (envelope, _) = cache.prepare_entry(&authority.authority_id, authority)?; let backing = SingleFileMessagePackBackingStore::new(store_path); let model_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("repo frontier Hands authority lost its current model"))?; let live_model: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(&model_envelope.payload)?; let live_snapshot = live_model.snapshot()?; if live_snapshot.model_revision != authority.model_revision || crate::memory_graph_model_hash(&live_snapshot)? != authority.model_hash { return Err(anyhow!( "repo frontier Hands authority model changed before insert" )); } if backing.compare_and_swap_batch(&[model_envelope.clone()], vec![model_envelope, envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&authority.authority_id)? { Some(existing) if existing == *authority => Ok(()), _ => Err(anyhow!("repo frontier Hands authority ids are immutable")), } } /// Atomically records Hands' inability to act under an exact route and lets /// Mind retire that route's frontier. The historical route and authority stay /// immutable, while the admitted model revision makes them structurally stale. pub fn relinquish_repo_frontier_hands_route( store_path: impl AsRef, intent_id: &str, review_id: &str, refusal_receipt_id: &str, missing_required_paths: Vec, summary: String, relinquished_at: String, ) -> Result { let store_path = store_path.as_ref(); validate_non_empty(intent_id, "Hands intent id")?; validate_non_empty(review_id, "Hands review id")?; validate_non_empty(refusal_receipt_id, "Hands refusal receipt id")?; validate_non_empty(&summary, "Hands refusal summary")?; if !safe_sorted_unique_paths(&missing_required_paths) || missing_required_paths.is_empty() { return Err(anyhow!( "Hands refusal requires non-empty safe missing paths in strict sorted order" )); } chrono::DateTime::parse_from_rfc3339(&relinquished_at) .map_err(|_| anyhow!("Hands refusal timestamp must be RFC3339"))?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; if let Some(existing) = cache.get::(refusal_receipt_id)? { if existing.intent_id != intent_id || existing.review_id != review_id || existing.missing_required_paths != missing_required_paths || existing.summary != summary || existing.refused_at != relinquished_at { return Err(anyhow!("Hands refusal receipt ids are immutable")); } let matches = cache .get_all::()? .into_iter() .filter(|receipt| receipt.hands_refusal_receipt_id == existing.receipt_id) .collect::>(); return match matches.as_slice() { [receipt] => Ok(receipt.clone()), _ => Err(anyhow!( "Hands refusal replay lost its unique Mind relinquishment receipt" )), }; } let authorities = cache .get_all::()? .into_iter() .filter(|authority| { authority.hands_intent_id == intent_id && authority.hands_review_id == review_id }) .collect::>(); let [authority] = authorities.as_slice() else { return Err(anyhow!( "Hands refusal requires exactly one current route authority" )); }; validate_repo_frontier_hands_authority_chain(&cache, authority)?; let route = cache .get::(&authority.route_id)? .ok_or_else(|| anyhow!("Hands refusal lost its route"))?; if missing_required_paths.iter().all(|path| { route.source_scope.iter().any(|scope| { path == scope || path.starts_with(&format!("{}/", scope.trim_end_matches(['/', '\\']))) }) }) { return Err(anyhow!( "Hands refusal must identify at least one required path outside the adopted route scope" )); } let has_consequence = cache .get_all::()? .iter() .any(|receipt| receipt.intent_id == intent_id) || cache .get_all::()? .iter() .any(|receipt| receipt.intent_id == intent_id) || cache .get_all::()? .iter() .any(|receipt| receipt.intent_id == intent_id) || cache .get_all::()? .iter() .any(|receipt| receipt.intent_id == intent_id); if has_consequence { return Err(anyhow!( "Hands cannot relinquish a route after mutation consequences exist" )); } let backing = SingleFileMessagePackBackingStore::new(store_path); let current_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("Hands refusal requires canonical RepoModel"))?; let current_entry: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(¤t_envelope.payload)?; crate::validate_memory_graph_entry(¤t_entry)?; let current = current_entry.snapshot()?; let current_hash = crate::memory_graph_model_hash(¤t)?; if current.model_revision != route.model_revision || current_hash != route.model_hash { return Err(anyhow!("Hands refusal route is no longer current")); } let refusal = HandsActionRefusalReceipt { schema_version: HANDS_ACTION_REFUSAL_RECEIPT_SCHEMA_VERSION.into(), receipt_id: refusal_receipt_id.to_string(), route_id: route.route_id.clone(), authority_id: authority.authority_id.clone(), intent_id: intent_id.to_string(), review_id: review_id.to_string(), substrate_gate_grant_receipt_id: authority.substrate_grant_receipt_id.clone(), model_revision: route.model_revision, model_hash: route.model_hash.clone(), frontier_item_id: route.frontier_item_id.clone(), frontier_item_hash: route.frontier_item_hash.clone(), missing_required_paths: missing_required_paths.clone(), summary: summary.clone(), refused_at: relinquished_at.clone(), contract: HANDS_ACTION_REFUSAL_RECEIPT_CONTRACT.into(), }; let relinquishment_id = format!( "repo-frontier-relinquishment-{:x}", Sha256::digest(format!("{}:{}", route.route_id, refusal.receipt_id).as_bytes()) ); let patch = crate::RepoModelPatch { patch_id: format!("repo-frontier-relinquishment-patch-{}", refusal.receipt_id), base_revision: current.model_revision, base_hash: current_hash.clone(), applied_at: relinquished_at.clone(), purpose: crate::RepoModelPatchPurpose::RelinquishFrontierRoute { route_id: route.route_id.clone(), hands_refusal_receipt_id: refusal.receipt_id.clone(), }, operations: vec![crate::RepoModelPatchOperation::RetireFrontier { item_id: route.frontier_item_id.clone(), retired_at: Some(relinquished_at.clone()), superseded_by: None, }], }; let patch_bytes = rmp_serde::to_vec_named(&patch)?; let patch_sha256 = format!("{:x}", Sha256::digest(&patch_bytes)); let next = crate::derive_repo_model_patch(¤t, &patch)?; let next_entry = crate::EpiphanyMemoryGraphEntry::from_snapshot(&next)?; let review_id_value = format!("repo-model-review-{relinquishment_id}"); let admission_id = format!("repo-model-admission-{relinquishment_id}"); let source = crate::RepoModelAdmissionSource::HandsRelinquishment { receipt_id: refusal.receipt_id.clone(), }; let review = RepoModelAdmissionReview { schema_version: REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION.into(), review_id: review_id_value.clone(), result_id: None, job_id: None, patch_id: patch.patch_id.clone(), patch_sha256: patch_sha256.clone(), base_revision: current.model_revision, base_hash: current_hash.clone(), decision: MindGatewayDecision::Accept, evidence_ids: vec![route.route_id.clone(), refusal.receipt_id.clone()], reviewed_at: relinquished_at.clone(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), repository_body_observation_basis: None, admission_source: Some(source.clone()), }; let admission = RepoModelAdmissionReceipt { schema_version: REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION.into(), receipt_id: admission_id.clone(), review_id: review_id_value, result_id: None, patch_id: patch.patch_id, patch_sha256, previous_revision: current.model_revision, previous_hash: current_hash, admitted_revision: next.model_revision, admitted_hash: next.model_hash.clone(), admitted_at: relinquished_at.clone(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), purpose: patch.purpose, frontier_route_id: route.route_id.clone(), verification_request_id: String::new(), soul_verdict_receipt_id: String::new(), frontier_modeling_request_id: String::new(), proposal_modeling_request_id: String::new(), claim_repair_request_id: String::new(), frontier_plan_decision_id: String::new(), repository_body_observation_basis: None, admission_source: Some(source), }; let relinquishment = RepoFrontierRelinquishmentReceipt { schema_version: crate::REPO_FRONTIER_RELINQUISHMENT_RECEIPT_SCHEMA_VERSION.into(), receipt_id: relinquishment_id, hands_refusal_receipt_id: refusal.receipt_id.clone(), route_id: route.route_id, frontier_item_id: route.frontier_item_id, previous_model_revision: current.model_revision, previous_model_hash: admission.previous_hash.clone(), admitted_model_revision: next.model_revision, admitted_model_hash: next.model_hash.clone(), model_admission_receipt_id: admission_id, relinquished_at: relinquished_at.clone(), contract: crate::REPO_FRONTIER_RELINQUISHMENT_RECEIPT_CONTRACT.into(), }; let obligation = modeling_projection_obligation( &cache, &next, &admission.receipt_id, &admission.admitted_at, )?; let writes = vec![ cache.prepare_entry(crate::MEMORY_GRAPH_KEY, &next_entry)?.0, cache.prepare_entry(&refusal.receipt_id, &refusal)?.0, cache.prepare_entry(&review.review_id, &review)?.0, cache.prepare_entry(&admission.receipt_id, &admission)?.0, cache .prepare_entry(&relinquishment.receipt_id, &relinquishment)? .0, cache .prepare_entry(&obligation.obligation_id, &obligation)? .0, ]; if !backing.compare_and_swap_batch(&[current_envelope], writes)? { return relinquish_repo_frontier_hands_route( store_path, intent_id, review_id, refusal_receipt_id, missing_required_paths, summary, relinquished_at, ); } Ok(relinquishment) } pub fn put_repo_frontier_verification_request( store_path: impl AsRef, request: &RepoFrontierVerificationRequest, ) -> Result<()> { let store_path = store_path.as_ref(); if request.schema_version != REPO_FRONTIER_VERIFICATION_REQUEST_SCHEMA_VERSION || request.contract != REPO_FRONTIER_VERIFICATION_REQUEST_CONTRACT || chrono::DateTime::parse_from_rfc3339(&request.requested_at).is_err() || request.request_id.trim().is_empty() { return Err(anyhow!( "invalid repo frontier verification request contract" )); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let route = cache .get::(&request.route_id)? .ok_or_else(|| anyhow!("verification request requires its exact frontier route"))?; let model_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("verification request requires the current repo model"))?; crate::validate_memory_graph_entry(&model_entry)?; let model = model_entry.snapshot()?; let authorities = cache .get_all::()? .into_iter() .filter(|value| { value.route_id == route.route_id && value.hands_intent_id == request.hands_intent_id }) .collect::>(); if authorities.len() != 1 { return Err(anyhow!( "verification request requires exactly one Hands authority" )); } let authority = &authorities[0]; validate_repo_frontier_hands_authority_chain(&cache, authority)?; let intent = cache .get::(&request.hands_intent_id)? .ok_or_else(|| anyhow!("verification request requires its Hands intent"))?; let review = cache .get::(&request.hands_review_id)? .ok_or_else(|| anyhow!("verification request requires its Hands review"))?; let patch = cache .get::(&request.hands_patch_receipt_id)? .ok_or_else(|| anyhow!("verification request requires its exact patch receipt"))?; let command = cache .get::(&request.hands_command_receipt_id)? .ok_or_else(|| anyhow!("verification request requires its exact command receipt"))?; let commit = cache .get::(&request.hands_commit_receipt_id)? .ok_or_else(|| anyhow!("verification request requires its exact commit receipt"))?; let adopted_plan_consequence_is_exact = route.adopted_plan.as_ref().is_none_or(|plan| { intent.frontier_route_id == route.route_id && intent.plan_candidate_sha256 == plan.candidate_sha256 && intent.plan_action == plan.action && command.command == plan.command }); if request.model_revision != route.model_revision || request.model_hash != route.model_hash || request.frontier_item_id != route.frontier_item_id || request.frontier_item_hash != route.frontier_item_hash || model.model_revision != route.model_revision || crate::memory_graph_model_hash(&model)? != route.model_hash || authority.hands_review_id != request.hands_review_id || authority.model_revision != request.model_revision || authority.model_hash != request.model_hash || authority.frontier_item_id != request.frontier_item_id || authority.frontier_item_hash != request.frontier_item_hash || review.intent_id != intent.intent_id || review.decision != "approved" || patch.intent_id != intent.intent_id || patch.review_id != review.review_id || patch.substrate_gate_grant_receipt_id != authority.substrate_grant_receipt_id || command.intent_id != intent.intent_id || command.review_id != review.review_id || command.substrate_gate_grant_receipt_id != authority.substrate_grant_receipt_id || commit.intent_id != intent.intent_id || commit.review_id != review.review_id || patch.runtime_job_id != intent.runtime_job_id || command.runtime_job_id != intent.runtime_job_id || commit.runtime_job_id != intent.runtime_job_id || patch.changed_paths != commit.changed_paths || !consequence_paths_within_authority(&patch.changed_paths, &authority.requested_paths) || !adopted_plan_consequence_is_exact { return Err(anyhow!( "verification request does not exactly bind route, model, Hands authority, and complete receipts" )); } let (envelope, _) = cache.prepare_entry(&request.request_id, request)?; let backing = SingleFileMessagePackBackingStore::new(store_path); let model_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("verification request lost its current model"))?; let live_model: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(&model_envelope.payload)?; let live_snapshot = live_model.snapshot()?; if live_snapshot.model_revision != request.model_revision || crate::memory_graph_model_hash(&live_snapshot)? != request.model_hash { return Err(anyhow!("verification request model changed before insert")); } if backing.compare_and_swap_batch(&[model_envelope.clone()], vec![model_envelope, envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&request.request_id)? { Some(existing) if existing == *request => Ok(()), _ => Err(anyhow!("verification request ids are immutable")), } } pub fn runtime_repo_frontier_verification_request( store_path: impl AsRef, request_id: &str, ) -> Result> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(request_id) } pub fn runtime_repo_frontier_route( store_path: impl AsRef, route_id: &str, ) -> Result> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(route_id) } pub fn runtime_latest_repo_frontier_relinquishment( store_path: impl AsRef, ) -> Result> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let mut receipts = cache.get_all::()?; receipts.sort_by(|left, right| { left.relinquished_at .cmp(&right.relinquished_at) .then_with(|| left.receipt_id.cmp(&right.receipt_id)) }); Ok(receipts.pop()) } pub fn commit_repo_frontier_modeling_request( store_path: impl AsRef, acceptance: &epiphany_state_model::EpiphanyAcceptanceReceipt, ) -> Result { if acceptance.role_id != "verification" || acceptance.surface != "roleAccept" || acceptance.status != "accepted" || acceptance.result_id.trim().is_empty() || acceptance.job_id.trim().is_empty() || chrono::DateTime::parse_from_rfc3339(&acceptance.accepted_at).is_err() { return Err(anyhow!( "frontier Modeling request requires one accepted Verification receipt" )); } let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let state = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("frontier Modeling request requires persisted coordinator state"))? .state()?; let persisted_acceptances = state .acceptance_receipts .iter() .filter(|candidate| candidate.id == acceptance.id) .collect::>(); if persisted_acceptances.len() != 1 || persisted_acceptances[0] != acceptance { return Err(anyhow!( "frontier Modeling request requires exactly one byte-exact persisted acceptance receipt" )); } let acceptance = persisted_acceptances[0]; let results = cache .get_all::()? .into_iter() .filter(|result| result.result_id == acceptance.result_id) .collect::>(); if results.len() != 1 { return Err(anyhow!( "frontier Modeling request requires one immutable accepted Verification result" )); } let result = &results[0]; let verdicts = cache .get_all::()? .into_iter() .filter(|verdict| { verdict.source_result_id == acceptance.result_id && verdict.source_job_id == acceptance.job_id }) .collect::>(); if verdicts.len() != 1 { return Err(anyhow!( "frontier Modeling request requires exactly one Soul verdict for the accepted result" )); } let verdict = &verdicts[0]; let verification_request = cache .get::(&verdict.verification_request_id)? .ok_or_else(|| anyhow!("frontier Modeling request requires the exact Soul request"))?; let route = cache .get::(&verdict.frontier_route_id)? .ok_or_else(|| anyhow!("frontier Modeling request requires the exact frontier route"))?; let model_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("frontier Modeling request requires the current repo model"))?; crate::validate_memory_graph_entry(&model_entry)?; let model = model_entry.snapshot()?; let model_hash = crate::memory_graph_model_hash(&model)?; let item = model .frontier .iter() .find(|item| item.id == route.frontier_item_id) .ok_or_else(|| anyhow!("frontier Modeling request routed item is missing"))?; let item_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)); let mut result_evidence = result.evidence_ids.clone(); let mut verdict_evidence = verdict.evidence_ids.clone(); result_evidence.sort(); result_evidence.dedup(); verdict_evidence.sort(); verdict_evidence.dedup(); let disposition = match verdict.verdict.trim().to_ascii_lowercase().as_str() { "pass" => RepoFrontierVerdictDisposition::Resolved, "needs-review" | "needs-evidence" | "fail" => RepoFrontierVerdictDisposition::Blocked, _ => return Err(anyhow!("Soul verdict has no allowed frontier disposition")), }; if result.schema_version != RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION || !result.role_id.eq_ignore_ascii_case("verification") || result.item_error.is_some() || result.job_id != acceptance.job_id || result.verification_request_id.as_deref() != Some(verification_request.request_id.as_str()) || result.frontier_route_id.as_deref() != Some(route.route_id.as_str()) || verdict.schema_version != SOUL_VERDICT_RECEIPT_SCHEMA_VERSION || verdict.verdict != result.verdict || verdict.summary != result.summary || verdict.risks != result.risks || verdict_evidence != result_evidence || verification_request.schema_version != REPO_FRONTIER_VERIFICATION_REQUEST_SCHEMA_VERSION || verification_request.contract != REPO_FRONTIER_VERIFICATION_REQUEST_CONTRACT || verification_request.route_id != route.route_id || verification_request.model_revision != route.model_revision || verification_request.model_hash != route.model_hash || verification_request.frontier_item_id != route.frontier_item_id || verification_request.frontier_item_hash != route.frontier_item_hash || model.model_revision != route.model_revision || model_hash != route.model_hash || item_hash != route.frontier_item_hash || item.status != crate::RepoFrontierStatus::Active { return Err(anyhow!( "frontier Modeling request does not exactly bind accepted result, Soul verdict, request, route, item, and current model" )); } let request_id = format!( "frontier-modeling-{:x}", Sha256::digest( format!( "{}:{}:{}:{}", acceptance.id, result.result_id, verdict.receipt_id, route.route_id ) .as_bytes() ) ); let request = RepoFrontierModelingRequest { schema_version: REPO_FRONTIER_MODELING_REQUEST_SCHEMA_VERSION.to_string(), request_id: request_id.clone(), model_revision: model.model_revision, model_hash, route_id: route.route_id.clone(), frontier_item_id: route.frontier_item_id.clone(), frontier_item_hash: route.frontier_item_hash.clone(), verification_request_id: verification_request.request_id.clone(), soul_verdict_receipt_id: verdict.receipt_id.clone(), verification_result_id: result.result_id.clone(), verification_job_id: result.job_id.clone(), verification_acceptance_receipt_id: acceptance.id.clone(), allowed_disposition: disposition, requested_at: acceptance.accepted_at.clone(), contract: REPO_FRONTIER_MODELING_REQUEST_CONTRACT.to_string(), }; let (envelope, _) = cache.prepare_entry(&request_id, &request)?; let backing = SingleFileMessagePackBackingStore::new(store_path.as_ref()); let model_envelope = backing .pull_all()? .into_iter() .find(|entry| { entry.r#type == crate::MEMORY_GRAPH_TYPE && entry.key == crate::MEMORY_GRAPH_KEY }) .ok_or_else(|| anyhow!("frontier Modeling request lost its current model"))?; let live_model: crate::EpiphanyMemoryGraphEntry = rmp_serde::from_slice(&model_envelope.payload)?; let live_snapshot = live_model.snapshot()?; if live_snapshot.model_revision != request.model_revision || crate::memory_graph_model_hash(&live_snapshot)? != request.model_hash { return Err(anyhow!( "frontier Modeling request model changed before insert" )); } if backing.compare_and_swap_batch(&[model_envelope.clone()], vec![model_envelope, envelope])? { return Ok(request); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&request_id)? { Some(existing) if existing == request => Ok(existing), _ => Err(anyhow!( "frontier Modeling request deterministic identity collision" )), } } fn consequence_paths_within_authority( changed_paths: &[String], authority_paths: &[String], ) -> bool { !changed_paths.is_empty() && changed_paths.iter().all(|path| { authority_paths.iter().any(|scope| { path == scope || path.starts_with(&format!("{}/", scope.trim_end_matches(['/', '\\']))) }) }) } pub fn commit_repo_frontier_verification_request_for_chain( store_path: impl AsRef, chain: &RuntimeHandsReceiptChainSummary, requested_at: &str, ) -> Result { let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; let authorities = cache .get_all::()? .into_iter() .filter(|value| { value.hands_intent_id == chain.intent_id && value.hands_review_id == chain.review_id }) .collect::>(); if authorities.len() != 1 { return Err(anyhow!( "complete Hands chain requires exactly one frontier authority before Soul launch" )); } let authority = &authorities[0]; let request_id = format!( "frontier-verification-{}-{}", authority.route_id, chain.commit_receipt_id ); let requested_at = cache .get::(&request_id)? .map(|existing| existing.requested_at) .unwrap_or_else(|| requested_at.to_string()); let request = RepoFrontierVerificationRequest { schema_version: REPO_FRONTIER_VERIFICATION_REQUEST_SCHEMA_VERSION.to_string(), request_id, route_id: authority.route_id.clone(), model_revision: authority.model_revision, model_hash: authority.model_hash.clone(), frontier_item_id: authority.frontier_item_id.clone(), frontier_item_hash: authority.frontier_item_hash.clone(), hands_intent_id: chain.intent_id.clone(), hands_review_id: chain.review_id.clone(), hands_patch_receipt_id: chain.patch_receipt_id.clone(), hands_command_receipt_id: chain.command_receipt_id.clone(), hands_commit_receipt_id: chain.commit_receipt_id.clone(), requested_at, contract: REPO_FRONTIER_VERIFICATION_REQUEST_CONTRACT.to_string(), }; put_repo_frontier_verification_request(store_path, &request)?; Ok(request) } fn safe_sorted_unique_paths(paths: &[String]) -> bool { paths.windows(2).all(|pair| pair[0] < pair[1]) && paths.iter().all(|path| { !path.is_empty() && !Path::new(path).is_absolute() && !Path::new(path) .components() .any(|part| matches!(part, std::path::Component::ParentDir)) }) } fn validate_hands_consequence_grant( store_path: &Path, intent_id: &str, review_id: &str, runtime_job_id: &str, operation: &str, changed_paths: &[String], stated_grant_id: Option<&str>, ) -> Result<()> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let intent = cache .get::(intent_id)? .ok_or_else(|| anyhow!("Hands consequence requires its persisted intent"))?; let review = cache .get::(review_id)? .ok_or_else(|| anyhow!("Hands consequence requires its persisted review"))?; let grant = cache .get::(&intent.substrate_gate_grant_receipt_id)? .ok_or_else(|| anyhow!("Hands consequence requires its persisted Substrate Gate grant"))?; let authorities = cache .get_all::()? .into_iter() .filter(|authority| authority.hands_intent_id == intent.intent_id) .collect::>(); if authorities.len() != 1 { return Err(anyhow!( "Hands consequence requires exactly one repo frontier authority for its intent" )); } let authority = &authorities[0]; let route = cache .get::(&authority.route_id)? .ok_or_else(|| anyhow!("Hands consequence requires its persisted repo frontier route"))?; let model_entry = cache .get::(crate::MEMORY_GRAPH_KEY)? .ok_or_else(|| anyhow!("Hands consequence requires the current repo model"))?; crate::validate_memory_graph_entry(&model_entry)?; let model = model_entry.snapshot()?; let paths_covered = changed_paths.iter().all(|path| { grant.granted_paths.iter().any(|granted| { granted == "." || path == granted || path.starts_with(&format!("{}/", granted.trim_end_matches(['/', '\\']))) }) }); if intent.runtime_job_id != runtime_job_id || review.intent_id != intent.intent_id || review.decision != "approved" || !review .allowed_operations .iter() .any(|allowed| allowed == operation) || grant.runtime_job_id != intent.runtime_job_id || grant.binding_id != intent.binding_id || grant.role != intent.role || grant.authority_scope != intent.authority_scope || !grant .granted_operations .iter() .any(|allowed| allowed == operation) || stated_grant_id.is_some_and(|id| id != grant.receipt_id) || !paths_covered || authority.schema_version != REPO_FRONTIER_HANDS_AUTHORITY_SCHEMA_VERSION || authority.contract != REPO_FRONTIER_HANDS_AUTHORITY_CONTRACT || authority.hands_review_id != review.review_id || authority.substrate_grant_receipt_id != grant.receipt_id || authority.requested_paths != intent.requested_paths || authority.route_id != route.route_id || authority.model_revision != route.model_revision || authority.model_hash != route.model_hash || authority.frontier_item_id != route.frontier_item_id || authority.frontier_item_hash != route.frontier_item_hash || model.model_revision != route.model_revision || crate::memory_graph_model_hash(&model)? != route.model_hash || !changed_paths.iter().all(|path| { authority.requested_paths.iter().any(|scope| { path == scope || path.starts_with(&format!("{}/", scope.trim_end_matches(['/', '\\']))) }) }) { return Err(anyhow!( "Hands consequence does not match its approved review and Substrate Gate grant" )); } Ok(()) } /// Revalidates the persisted Hands/Substrate authority chain before an actuator /// performs a consequence. Receipt writers call the same primitive again after /// the consequence; this preflight prevents a stale or substituted grant from /// authorizing the consequence in the first place. pub fn validate_hands_action_authority( store_path: impl AsRef, intent_id: &str, review_id: &str, runtime_job_id: &str, operation: &str, changed_paths: &[String], stated_grant_id: &str, ) -> Result<()> { validate_hands_consequence_grant( store_path.as_ref(), intent_id, review_id, runtime_job_id, operation, changed_paths, Some(stated_grant_id), ) } pub fn put_hands_patch_receipt( store_path: impl AsRef, receipt: &HandsPatchReceipt, ) -> Result<()> { let store_path = store_path.as_ref(); validate_non_empty(&receipt.receipt_id, "Hands patch receipt id")?; validate_non_empty(&receipt.intent_id, "Hands patch intent")?; validate_non_empty(&receipt.review_id, "Hands patch review")?; validate_non_empty( &receipt.substrate_gate_grant_receipt_id, "Hands patch Substrate Gate grant receipt", )?; validate_non_empty(&receipt.runtime_job_id, "Hands patch runtime job")?; validate_non_empty(&receipt.summary, "Hands patch summary")?; validate_non_empty(&receipt.emitted_at, "Hands patch timestamp")?; if receipt.changed_paths.is_empty() { return Err(anyhow!("Hands patch receipt must name changed paths")); } validate_hands_consequence_grant( store_path.as_ref(), &receipt.intent_id, &receipt.review_id, &receipt.runtime_job_id, "patch", &receipt.changed_paths, Some(&receipt.substrate_gate_grant_receipt_id), )?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let (envelope, _) = cache.prepare_entry(&receipt.receipt_id, receipt)?; if SingleFileMessagePackBackingStore::new(store_path) .compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&receipt.receipt_id)? { Some(existing) if existing == *receipt => Ok(()), _ => Err(anyhow!("Hands patch receipt ids are immutable")), } } pub fn runtime_hands_patch_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Hands patch receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn put_hands_command_receipt( store_path: impl AsRef, receipt: &HandsCommandReceipt, ) -> Result<()> { let store_path = store_path.as_ref(); validate_non_empty(&receipt.receipt_id, "Hands command receipt id")?; validate_non_empty(&receipt.intent_id, "Hands command intent")?; validate_non_empty(&receipt.review_id, "Hands command review")?; validate_non_empty( &receipt.substrate_gate_grant_receipt_id, "Hands command Substrate Gate grant receipt", )?; validate_non_empty(&receipt.runtime_job_id, "Hands command runtime job")?; validate_non_empty(&receipt.command, "Hands command")?; validate_non_empty(&receipt.exit_code, "Hands command exit code")?; validate_non_empty(&receipt.emitted_at, "Hands command timestamp")?; validate_hands_consequence_grant( store_path.as_ref(), &receipt.intent_id, &receipt.review_id, &receipt.runtime_job_id, "command", &[], Some(&receipt.substrate_gate_grant_receipt_id), )?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let (envelope, _) = cache.prepare_entry(&receipt.receipt_id, receipt)?; if SingleFileMessagePackBackingStore::new(store_path) .compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&receipt.receipt_id)? { Some(existing) if existing == *receipt => Ok(()), _ => Err(anyhow!("Hands command receipt ids are immutable")), } } pub fn runtime_hands_command_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Hands command receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn put_hands_commit_receipt( store_path: impl AsRef, receipt: &HandsCommitReceipt, ) -> Result<()> { let store_path = store_path.as_ref(); validate_non_empty(&receipt.receipt_id, "Hands commit receipt id")?; validate_non_empty(&receipt.intent_id, "Hands commit intent")?; validate_non_empty(&receipt.review_id, "Hands commit review")?; validate_non_empty(&receipt.runtime_job_id, "Hands commit runtime job")?; validate_non_empty(&receipt.commit_sha, "Hands commit sha")?; validate_non_empty(&receipt.branch, "Hands commit branch")?; validate_non_empty(&receipt.summary, "Hands commit summary")?; validate_non_empty(&receipt.emitted_at, "Hands commit timestamp")?; if receipt.changed_paths.is_empty() { return Err(anyhow!("Hands commit receipt must name changed paths")); } validate_hands_consequence_grant( store_path.as_ref(), &receipt.intent_id, &receipt.review_id, &receipt.runtime_job_id, "commit", &receipt.changed_paths, None, )?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let (envelope, _) = cache.prepare_entry(&receipt.receipt_id, receipt)?; if SingleFileMessagePackBackingStore::new(store_path) .compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&receipt.receipt_id)? { Some(existing) if existing == *receipt => Ok(()), _ => Err(anyhow!("Hands commit receipt ids are immutable")), } } pub fn runtime_hands_commit_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Hands commit receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } #[cfg(test)] pub fn put_hands_pr_receipt(store_path: impl AsRef, receipt: &HandsPrReceipt) -> Result<()> { validate_non_empty(&receipt.receipt_id, "Hands PR receipt id")?; validate_non_empty(&receipt.intent_id, "Hands PR intent")?; validate_non_empty(&receipt.review_id, "Hands PR review")?; validate_non_empty(&receipt.runtime_job_id, "Hands PR runtime job")?; validate_non_empty(&receipt.commit_receipt_id, "Hands PR commit receipt")?; validate_non_empty(&receipt.commit_sha, "Hands PR commit sha")?; validate_non_empty(&receipt.branch, "Hands PR branch")?; validate_non_empty(&receipt.pull_request_url, "Hands PR url")?; validate_non_empty(&receipt.pull_request_number, "Hands PR number")?; validate_non_empty(&receipt.pull_request_title, "Hands PR title")?; validate_non_empty( &receipt.bifrost_publication_receipt_id, "Hands PR Bifrost publication receipt", )?; validate_non_empty(&receipt.summary, "Hands PR summary")?; validate_non_empty(&receipt.emitted_at, "Hands PR timestamp")?; if receipt.changed_paths.is_empty() { return Err(anyhow!("Hands PR receipt must name changed paths")); } let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.put(&receipt.receipt_id, receipt)?; Ok(()) } pub fn runtime_hands_pr_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Hands PR receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn runtime_hands_receipt_chain_after( store_path: impl AsRef, after_timestamp: &str, ) -> Result { Ok(runtime_latest_hands_receipt_chain_after(store_path, after_timestamp)?.is_some()) } #[derive(Debug, Clone, PartialEq, Eq)] pub struct RuntimeHandsReceiptChainSummary { pub patch_schema_version: String, pub patch_receipt_id: String, pub command_schema_version: String, pub command_receipt_id: String, pub commit_schema_version: String, pub commit_receipt_id: String, pub intent_id: String, pub review_id: String, pub runtime_job_id: String, pub substrate_gate_grant_receipt_id: String, pub changed_paths: Vec, pub command: String, pub exit_code: String, pub stdout_artifact: String, pub stderr_artifact: String, pub commit_sha: String, pub branch: String, pub summary: String, pub emitted_at: String, } pub fn runtime_latest_hands_receipt_chain_after( store_path: impl AsRef, after_timestamp: &str, ) -> Result> { validate_non_empty(after_timestamp, "Hands receipt lower-bound timestamp")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; let patches = cache.get_all::()?; let commands = cache.get_all::()?; let commits = cache.get_all::()?; let mut summaries = Vec::new(); for commit in commits .iter() .filter(|commit| timestamp_after(&commit.emitted_at, after_timestamp)) { let Some(patch) = patches .iter() .filter(|patch| { patch.intent_id == commit.intent_id && patch.review_id == commit.review_id && patch.runtime_job_id == commit.runtime_job_id && timestamp_after(&patch.emitted_at, after_timestamp) && patch.emitted_at <= commit.emitted_at }) .max_by(|left, right| left.emitted_at.cmp(&right.emitted_at)) else { continue; }; let Some(command) = commands .iter() .filter(|command| { command.intent_id == commit.intent_id && command.review_id == commit.review_id && command.runtime_job_id == commit.runtime_job_id && command.exit_code == "0" && timestamp_after(&command.emitted_at, after_timestamp) && command.emitted_at <= commit.emitted_at }) .max_by(|left, right| left.emitted_at.cmp(&right.emitted_at)) else { continue; }; summaries.push(RuntimeHandsReceiptChainSummary { patch_schema_version: patch.schema_version.clone(), patch_receipt_id: patch.receipt_id.clone(), command_schema_version: command.schema_version.clone(), command_receipt_id: command.receipt_id.clone(), commit_schema_version: commit.schema_version.clone(), commit_receipt_id: commit.receipt_id.clone(), intent_id: commit.intent_id.clone(), review_id: commit.review_id.clone(), runtime_job_id: commit.runtime_job_id.clone(), substrate_gate_grant_receipt_id: command.substrate_gate_grant_receipt_id.clone(), changed_paths: commit.changed_paths.clone(), command: command.command.clone(), exit_code: command.exit_code.clone(), stdout_artifact: command.stdout_artifact.clone(), stderr_artifact: command.stderr_artifact.clone(), commit_sha: commit.commit_sha.clone(), branch: commit.branch.clone(), summary: commit.summary.clone(), emitted_at: commit.emitted_at.clone(), }); } summaries.sort_by(|left, right| left.emitted_at.cmp(&right.emitted_at)); Ok(summaries.pop()) } pub fn put_soul_verdict_receipt( store_path: impl AsRef, receipt: &SoulVerdictReceipt, ) -> Result<()> { let store_path = store_path.as_ref(); validate_non_empty(&receipt.receipt_id, "Soul verdict receipt id")?; validate_non_empty(&receipt.source_result_id, "Soul verdict source result")?; validate_non_empty(&receipt.source_job_id, "Soul verdict source job")?; validate_non_empty(&receipt.verdict, "Soul verdict")?; validate_non_empty(&receipt.emitted_at, "Soul verdict timestamp")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let (envelope, _) = cache.prepare_entry(&receipt.receipt_id, receipt)?; if SingleFileMessagePackBackingStore::new(store_path) .compare_and_swap_batch(&[], vec![envelope])? { return Ok(()); } let mut reloaded = runtime_spine_cache(store_path)?; reloaded.pull_all_backing_stores()?; match reloaded.get::(&receipt.receipt_id)? { Some(existing) if existing == *receipt => Ok(()), _ => Err(anyhow!( "Soul verdict receipt id already belongs to different immutable evidence" )), } } pub fn runtime_soul_verdict_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Soul verdict receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn put_continuity_recovery_receipt( store_path: impl AsRef, receipt: &ContinuityRecoveryReceipt, ) -> Result<()> { validate_non_empty(&receipt.receipt_id, "Continuity recovery receipt id")?; validate_non_empty( &receipt.source_result_id, "Continuity recovery source result", )?; validate_non_empty(&receipt.source_job_id, "Continuity recovery source job")?; validate_non_empty(&receipt.binding_id, "Continuity recovery binding")?; validate_non_empty(&receipt.mode, "Continuity recovery mode")?; validate_non_empty( &receipt.checkpoint_still_valid, "Continuity recovery checkpoint validity", )?; validate_non_empty(&receipt.emitted_at, "Continuity recovery timestamp")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.put(&receipt.receipt_id, receipt)?; Ok(()) } pub fn runtime_continuity_recovery_receipt( store_path: impl AsRef, receipt_id: &str, ) -> Result> { validate_non_empty(receipt_id, "Continuity recovery receipt id")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; cache.get::(receipt_id) } pub fn put_coordinator_run_receipt( store_path: impl AsRef, receipt: &EpiphanyCoordinatorRunReceipt, ) -> Result<()> { validate_non_empty(&receipt.receipt_id, "coordinator run receipt id")?; validate_non_empty(&receipt.session_id, "coordinator run receipt session id")?; validate_non_empty(&receipt.thread_id, "coordinator run receipt thread id")?; validate_non_empty(&receipt.mode, "coordinator run receipt mode")?; validate_non_empty(&receipt.status, "coordinator run receipt status")?; validate_non_empty( &receipt.final_action, "coordinator run receipt final action", )?; validate_non_empty(&receipt.created_at, "coordinator run receipt created at")?; let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.put(&receipt.receipt_id, receipt)?; Ok(()) } pub fn coordinator_run_receipts( store_path: impl AsRef, ) -> Result> { let mut cache = runtime_spine_cache(store_path)?; cache.pull_all_backing_stores()?; require_identity(&cache)?; cache.get_all::() } pub fn complete_runtime_job( store_path: impl AsRef, options: RuntimeSpineJobResultOptions, ) -> Result { validate_non_empty(&options.result_id, "result id")?; validate_non_empty(&options.job_id, "job id")?; validate_non_empty(&options.completed_at, "completed at")?; validate_non_empty(&options.verdict, "verdict")?; validate_non_empty(&options.summary, "summary")?; let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; require_identity(&cache)?; let mut job = cache .get::(&options.job_id)? .ok_or_else(|| anyhow!("runtime job {:?} does not exist", options.job_id))?; if matches!( job.status, EpiphanyRuntimeJobStatus::Completed | EpiphanyRuntimeJobStatus::Failed | EpiphanyRuntimeJobStatus::Cancelled ) { return Err(anyhow!( "runtime job {:?} is already terminal", options.job_id )); } if cache .get::(&options.result_id)? .is_some() { return Err(anyhow!( "runtime job result {:?} already exists", options.result_id )); } let terminal_status = terminal_status_for_verdict(&options.verdict); job.status = terminal_status; job.updated_at = options.completed_at.clone(); job.summary = options.summary.clone(); job.artifact_refs = merge_refs(&job.artifact_refs, &options.artifact_refs); let result = EpiphanyRuntimeJobResult { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), result_id: options.result_id.clone(), job_id: options.job_id.clone(), session_id: job.session_id.clone(), role: job.role.clone(), verdict: options.verdict, summary: options.summary, completed_at: options.completed_at.clone(), next_safe_move: options.next_safe_move, evidence_refs: options.evidence_refs, artifact_refs: options.artifact_refs, metadata: BTreeMap::new(), }; cache.put(&job.job_id, &job)?; cache.put(&result.result_id, &result)?; let event = EpiphanyRuntimeEvent { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), event_id: format!("event-job-completed-{}", options.job_id), occurred_at: options.completed_at, event_type: "job.completed".to_string(), source: "runtime-spine".to_string(), session_id: Some(result.session_id.clone()), job_id: Some(options.job_id), summary: format!( "Native runtime job completed with verdict {}.", result.verdict ), metadata: BTreeMap::from([("resultId".to_string(), result.result_id.clone())]), }; cache.put(&event.event_id, &event)?; Ok(result) } pub fn append_runtime_event( store_path: impl AsRef, options: RuntimeSpineEventOptions, ) -> Result { validate_non_empty(&options.event_id, "event id")?; validate_non_empty(&options.occurred_at, "occurred at")?; validate_non_empty(&options.event_type, "event type")?; validate_non_empty(&options.source, "source")?; let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; require_identity(&cache)?; if cache .get::(&options.event_id)? .is_some() { return Err(anyhow!( "runtime event {:?} already exists", options.event_id )); } let event = EpiphanyRuntimeEvent { schema_version: RUNTIME_SPINE_SCHEMA_VERSION.to_string(), event_id: options.event_id.clone(), occurred_at: options.occurred_at, event_type: options.event_type, source: options.source, session_id: options.session_id, job_id: options.job_id, summary: options.summary, metadata: BTreeMap::new(), }; cache.put(&options.event_id, &event)?; Ok(event) } pub fn runtime_spine_status(store_path: impl AsRef) -> Result { let store_path = store_path.as_ref(); if !store_path.exists() { return Ok(EpiphanyRuntimeSpineStatus { store: store_path.display().to_string(), present: false, runtime_id: None, display_name: None, sessions: 0, active_sessions: 0, jobs: 0, open_jobs: 0, job_results: 0, events: 0, tool_invocation_intents: 0, tool_invocation_receipts: 0, pending_tool_invocations: 0, supported_document_types: Vec::new(), }); } let mut cache = runtime_spine_cache(store_path)?; cache .pull_all_backing_stores() .with_context(|| format!("failed to read runtime spine {}", store_path.display()))?; let identity = cache.get::(RUNTIME_IDENTITY_KEY)?; let sessions = cache.get_all::()?; let jobs = cache.get_all::()?; let job_results = cache.get_all::()?; let events = cache.get_all::()?; let tool_intents = cache.get_all::()?; let tool_receipts = cache.get_all::()?; let receipt_intent_ids = tool_receipts .iter() .map(|receipt| receipt.intent_id.as_str()) .collect::>(); let active_sessions = sessions .iter() .filter(|session| { matches!( session.status, EpiphanyRuntimeSessionStatus::Active | EpiphanyRuntimeSessionStatus::WaitingForReview ) }) .count(); let open_jobs = jobs .iter() .filter(|job| { matches!( job.status, EpiphanyRuntimeJobStatus::Queued | EpiphanyRuntimeJobStatus::Running | EpiphanyRuntimeJobStatus::WaitingForReview ) }) .count(); Ok(EpiphanyRuntimeSpineStatus { store: store_path.display().to_string(), present: identity.is_some(), runtime_id: identity.as_ref().map(|item| item.runtime_id.clone()), display_name: identity.as_ref().map(|item| item.display_name.clone()), sessions: sessions.len(), active_sessions, jobs: jobs.len(), open_jobs, job_results: job_results.len(), events: events.len(), tool_invocation_intents: tool_intents.len(), tool_invocation_receipts: tool_receipts.len(), pending_tool_invocations: tool_intents .iter() .filter(|intent| !receipt_intent_ids.contains(intent.intent_id.as_str())) .count(), supported_document_types: identity .is_some() .then(runtime_registered_document_types) .unwrap_or_default(), }) } pub fn runtime_tool_invocation_statuses( store_path: impl AsRef, ) -> Result> { let store_path = store_path.as_ref(); if !store_path.exists() { return Ok(Vec::new()); } let mut cache = runtime_spine_cache(store_path)?; cache .pull_all_backing_stores() .with_context(|| format!("failed to read runtime spine {}", store_path.display()))?; let mut receipts = cache .get_all::()? .into_iter() .map(|receipt| (receipt.intent_id.clone(), receipt)) .collect::>(); let mut statuses = cache .get_all::()? .into_iter() .map(|intent| { let receipt = receipts.remove(&intent.intent_id); EpiphanyToolInvocationStatus { intent_id: intent.intent_id, adapter: intent.adapter, server: intent.server, tool_name: intent.tool_name, call_id: intent.call_id, model_request_id: intent.model_request_id, caller: intent.caller, reason: intent.reason, created_at: intent.created_at, status: receipt .as_ref() .map(|receipt| receipt.status.clone()) .unwrap_or_else(|| "pending".to_string()), receipt_id: receipt.as_ref().map(|receipt| receipt.receipt_id.clone()), completed_at: receipt.as_ref().map(|receipt| receipt.completed_at.clone()), error: receipt.and_then(|receipt| receipt.error), } }) .collect::>(); statuses.sort_by(|left, right| { left.created_at .cmp(&right.created_at) .then_with(|| left.intent_id.cmp(&right.intent_id)) }); Ok(statuses) } pub fn runtime_hello_frame(store_path: impl AsRef) -> Result> { let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; let identity = require_identity(&cache)?; let message = CultNetMessage::Hello { runtime_id: identity.runtime_id, runtime_kind: identity.runtime_kind, agent_id: Some("self".to_string()), role: Some("coordinator".to_string()), display_name: Some(identity.display_name), supported_document_types: Some(runtime_registered_document_types()), supported_mutation_contracts: Some(epiphany_mutation_contracts()), supported_message_versions: Some(vec![ "cultnet.hello.v0".to_string(), "cultnet.document_put.v0".to_string(), "cultnet.snapshot_request.v0".to_string(), "cultnet.snapshot_response.v0".to_string(), "cultnet.schema_catalog_request.v0".to_string(), "cultnet.schema_catalog_response.v0".to_string(), ]), transport_profiles: None, supports_schema_catalog: Some(true), }; let payload = encode_cultnet_message_to_vec(&message, CultNetWireContract::CultNetSchemaV0)?; encode_frame(&payload) } pub fn write_runtime_hello_frame( store_path: impl AsRef, output_path: impl AsRef, ) -> Result { let output_path = output_path.as_ref(); if let Some(parent) = output_path.parent() { fs::create_dir_all(parent) .with_context(|| format!("failed to create {}", parent.display()))?; } let frame = runtime_hello_frame(store_path)?; fs::write(output_path, &frame) .with_context(|| format!("failed to write {}", output_path.display()))?; Ok(frame.len()) } pub fn epiphany_schema_registry() -> Result { let mut registry = builtin_schema_registry()?; let schema_root = epiphany_schema_root(); let index_path = schema_root.join("index.json"); let raw_index = fs::read_to_string(&index_path) .with_context(|| format!("failed to read {}", index_path.display()))?; let index: EpiphanyCultNetSchemaIndex = serde_json::from_str(&raw_index) .with_context(|| format!("failed to parse {}", index_path.display()))?; if index.schema_version.trim().is_empty() { return Err(anyhow!( "CultNet schema index at {} is missing schemaVersion", index_path.display() )); } for entry in index.schemas { let schema_path = schema_root.join(&entry.path); let schema_json = fs::read_to_string(&schema_path) .with_context(|| format!("failed to read {}", schema_path.display()))?; registry.register(CultNetSchemaRegistration { schema_id: entry.schema_id, kind: entry.kind, wire_contracts: entry.wire_contracts, schema_version: entry.schema_version, document_type: entry.document_type, title: entry.title, schema_json: Some(schema_json), })?; } Ok(registry) } pub fn runtime_schema_catalog_response( message_id: impl Into, include_schema_json: bool, schema_ids: Option>, kinds: Option>, ) -> Result { let registry = epiphany_schema_registry()?; registry.create_catalog_response(&CultNetMessage::SchemaCatalogRequest { message_id: message_id.into(), include_schema_json: Some(include_schema_json), schema_ids, kinds, }) } pub fn write_runtime_schema_catalog_json( output_path: impl AsRef, include_schema_json: bool, ) -> Result { let output_path = output_path.as_ref(); if let Some(parent) = output_path.parent() { fs::create_dir_all(parent) .with_context(|| format!("failed to create {}", parent.display()))?; } let response = runtime_schema_catalog_response( "runtime-spine-schema-catalog".to_string(), include_schema_json, None, None, )?; let body = serde_json::to_vec_pretty(&response)?; fs::write(output_path, &body) .with_context(|| format!("failed to write {}", output_path.display()))?; Ok(body.len()) } fn epiphany_schema_root() -> PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")) .parent() .expect("epiphany-core has no parent repo root") .join(CULTNET_SCHEMA_INDEX_RELATIVE) .parent() .expect("cultnet schema index has no parent directory") .to_path_buf() } fn require_identity(cache: &CultCache) -> Result { cache .get::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("runtime spine is missing identity; run init first")) } pub fn runtime_registered_document_types() -> Vec { let mut document_types = Vec::new(); for contract in epiphany_mutation_contracts() { if !document_types.contains(&contract.document_type) { document_types.push(contract.document_type); } } document_types } fn mutation_contract( document_type: impl Into, payload_schema_version: impl Into, operations: Vec, authority: CultNetMutationAuthority, intent_document_types: Vec<&str>, receipt_document_types: Vec<&str>, notes: Vec<&str>, ) -> CultNetDocumentMutationContract { CultNetDocumentMutationContract { document_type: document_type.into(), payload_schema_version: Some(payload_schema_version.into()), operations, authority, intent_document_types: (!intent_document_types.is_empty()).then(|| { intent_document_types .into_iter() .map(str::to_string) .collect() }), receipt_document_types: (!receipt_document_types.is_empty()).then(|| { receipt_document_types .into_iter() .map(str::to_string) .collect() }), notes: (!notes.is_empty()).then(|| notes.into_iter().map(str::to_string).collect()), } } fn epiphany_mutation_contracts() -> Vec { vec![ mutation_contract( crate::USER_OBJECTIVE_INTAKE_TYPE, crate::USER_OBJECTIVE_INTAKE_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, ], CultNetMutationAuthority::Coordinator, vec![crate::USER_OBJECTIVE_INTAKE_TYPE], vec![crate::THREAD_STATE_TYPE], vec![ "The human owns the initial objective assertion; Self atomically records it with the first canonical thread state.", "Objective replacement requires a separate reviewed adoption flow.", ], ), mutation_contract( RUNTIME_IDENTITY_TYPE, RUNTIME_SPINE_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Runtime identity is advertised by the coordinator, not remotely mutated."], ), mutation_contract( RUNTIME_SESSION_TYPE, RUNTIME_SPINE_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec!["epiphany.runtime.session_intent.v0"], vec!["epiphany.swarm_control_receipt.v0"], vec!["Sessions change through coordinator-reviewed typed intents."], ), mutation_contract( RUNTIME_JOB_TYPE, RUNTIME_SPINE_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec!["epiphany.heartbeat_pump_intent.v0"], vec!["epiphany.swarm_control_receipt.v0"], vec![ "Heartbeat activation owns agent work; external callers submit intents and watch receipts.", ], ), mutation_contract( RUNTIME_WORKER_LAUNCH_REQUEST_TYPE, RUNTIME_WORKER_LAUNCH_REQUEST_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![RUNTIME_WORKER_LAUNCH_REQUEST_TYPE], vec![RUNTIME_JOB_TYPE], vec![ "Worker launch requests are typed task-intent documents; runtime jobs are lifecycle receipts, not the source of work intent.", "Core/coordinator policy owns the launch yes/no; the Epiphany-Codex bridge translates between CultNet-shaped intent and Codex JSON only.", "Codex-hosted executors may gather host facts and perform side effects after the verdict, with readable receipts.", ], ), mutation_contract( RUNTIME_ROLE_WORKER_RESULT_TYPE, RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Role worker results preserve the typed finding payload; generic runtime job results are lifecycle receipts.", ], ), mutation_contract( RUNTIME_REORIENT_WORKER_RESULT_TYPE, RUNTIME_REORIENT_WORKER_RESULT_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Reorient worker results preserve continuity findings separately from generic runtime lifecycle receipts.", ], ), mutation_contract( RUNTIME_JOB_RESULT_TYPE, RUNTIME_SPINE_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Job results are evidence records; review and acceptance are separate typed flows.", ], ), mutation_contract( MIND_THOUGHT_TYPE, MIND_THOUGHT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![MIND_THOUGHT_TYPE], vec![MIND_GATEWAY_REVIEW_TYPE, MIND_STATE_REJECTION_RECEIPT_TYPE], vec![ "Sub-agent output enters Epiphany as thought, not durable state authority.", "The Mind contract is the gateway between worker output and persistent state.", ], ), mutation_contract( MIND_STATE_EFFECT_PROPOSAL_TYPE, MIND_STATE_EFFECT_PROPOSAL_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![MIND_STATE_EFFECT_PROPOSAL_TYPE], vec![ MIND_GATEWAY_REVIEW_TYPE, MIND_STATE_COMMIT_RECEIPT_TYPE, MIND_STATE_REJECTION_RECEIPT_TYPE, ], vec![ "Mind is the persistent state guardian: role acceptance, reorientation acceptance, Persona Interpreter effects, selfPatch, evidence, scratch, checkpoints, graph changes, and objective changes share this gate.", "Workers and public Verse ingress propose effects; Mind accepts, refuses, or holds them before any durable state mutation.", ], ), mutation_contract( MIND_GATEWAY_REVIEW_TYPE, MIND_GATEWAY_REVIEW_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Mind reviews are durable receipts explaining accepted, refused, or held state effects.", ], ), mutation_contract( MIND_STATE_COMMIT_RECEIPT_TYPE, MIND_STATE_COMMIT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "A commit receipt is proof that Mind, not the worker, admitted a proposed effect into durable state.", ], ), mutation_contract( MIND_STATE_REJECTION_RECEIPT_TYPE, MIND_STATE_REJECTION_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "A rejection receipt preserves why a thought or state effect was refused without mutating the Mind.", ], ), mutation_contract( MIND_VERSE_ADOPTION_RECEIPT_TYPE, MIND_VERSE_ADOPTION_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Foreign or public Verse material is thought weather until local Mind emits an adoption receipt.", "The global Verse never receives private state authority by being interesting.", ], ), mutation_contract( SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE, SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE], vec![ SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE, SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, ], vec![ "Substrate Gate is the repository access protocol: reads, indexing, edits, commands, and bridge operations must be requested through this contract.", "Hands mutates only after a scoped Substrate Gate grant; Eyes inspects only after a scoped Substrate Gate read/index grant.", ], ), mutation_contract( SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE, SUBSTRATE_GATE_REPO_ACCESS_REVIEW_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Substrate Gate reviews explain granted/refused repo paths, operations, commands, and bridge surfaces.", ], ), mutation_contract( SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["A Substrate Gate grant receipt scopes a permitted repo touch."], ), mutation_contract( SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["A Substrate Gate refusal receipt preserves why repo access was denied."], ), mutation_contract( SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Repo snapshots are evidence projections from Substrate-Gate-scoped access."], ), mutation_contract( SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Repo mutation receipts prove Substrate Gate granted the substrate touch before Hands changed files or ran repo-affecting commands.", ], ), mutation_contract( EYES_EVIDENCE_REQUEST_TYPE, EYES_EVIDENCE_REQUEST_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![EYES_EVIDENCE_REQUEST_TYPE], vec![ EYES_EVIDENCE_REVIEW_TYPE, EYES_SOURCE_LOOKUP_RECEIPT_TYPE, EYES_EVIDENCE_PACKET_TYPE, EYES_EVIDENCE_REFUSAL_RECEIPT_TYPE, ], vec![ "Eyes is the evidence ingress guardian: source-grounded claims, provenance, uncertainty, and evidence packets enter through this contract.", "Substrate Gate grants substrate access; Eyes decides what was actually inspected and what other organs may cite.", ], ), mutation_contract( EYES_EVIDENCE_REVIEW_TYPE, EYES_EVIDENCE_REVIEW_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Eyes reviews explain whether a claim is source-grounded, uncertain, or refused."], ), mutation_contract( EYES_SOURCE_LOOKUP_RECEIPT_TYPE, EYES_SOURCE_LOOKUP_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Source lookup receipts prove what was searched or inspected under a Substrate Gate grant.", ], ), mutation_contract( EYES_EVIDENCE_PACKET_TYPE, EYES_EVIDENCE_PACKET_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Evidence packets carry provenance, uncertainty, and source refs for the other organs.", ], ), mutation_contract( EYES_EVIDENCE_REFUSAL_RECEIPT_TYPE, EYES_EVIDENCE_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Evidence refusal receipts preserve why Eyes would not certify a claim."], ), mutation_contract( HANDS_ACTION_INTENT_TYPE, HANDS_ACTION_INTENT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![HANDS_ACTION_INTENT_TYPE], vec![ HANDS_ACTION_REVIEW_TYPE, HANDS_COMMAND_RECEIPT_TYPE, HANDS_PATCH_RECEIPT_TYPE, HANDS_COMMIT_RECEIPT_TYPE, HANDS_PR_RECEIPT_TYPE, HANDS_ROLLBACK_RECEIPT_TYPE, HANDS_ACTION_REFUSAL_RECEIPT_TYPE, ], vec![ "Hands is the action organ: commands, patches, commits, PRs, and rollbacks enter as bounded action intents.", "Substrate Gate grants substrate access before Hands mutates; Soul verifies consequences after.", ], ), mutation_contract( HANDS_ACTION_REVIEW_TYPE, HANDS_ACTION_REVIEW_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Hands reviews explain allowed, refused, sequenced, or delegated action."], ), mutation_contract( HANDS_COMMAND_RECEIPT_TYPE, HANDS_COMMAND_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Command receipts prove what command ran and under which Substrate Gate grant."], ), mutation_contract( HANDS_PATCH_RECEIPT_TYPE, HANDS_PATCH_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Patch receipts prove file mutations and the scoped grant that permitted them."], ), mutation_contract( HANDS_COMMIT_RECEIPT_TYPE, HANDS_COMMIT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![HANDS_PR_RECEIPT_TYPE], vec!["Commit receipts preserve publication consequences after verification."], ), mutation_contract( HANDS_PR_RECEIPT_TYPE, HANDS_PR_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["PR receipts preserve outward publication consequences for operator review."], ), mutation_contract( HANDS_ROLLBACK_RECEIPT_TYPE, HANDS_ROLLBACK_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Rollback receipts prove failed action was unwound instead of hidden."], ), mutation_contract( HANDS_ACTION_REFUSAL_RECEIPT_TYPE, HANDS_ACTION_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Hands refusal receipts preserve why an action intent was denied."], ), mutation_contract( crate::REPO_FRONTIER_RELINQUISHMENT_RECEIPT_TYPE, crate::REPO_FRONTIER_RELINQUISHMENT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Mind relinquishment receipts prove that an exact Hands refusal retired route authority without a repository consequence."], ), mutation_contract( SOUL_VERIFICATION_REQUEST_TYPE, SOUL_VERIFICATION_REQUEST_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![SOUL_VERIFICATION_REQUEST_TYPE], vec![ SOUL_INVARIANT_CHECK_TYPE, SOUL_VERDICT_RECEIPT_TYPE, SOUL_REGRESSION_RECEIPT_TYPE, SOUL_REVIEW_RECEIPT_TYPE, SOUL_VERIFICATION_REFUSAL_RECEIPT_TYPE, ], vec![ "Soul is the verification organ: invariants, tests, review, falsification, and refusal enter here.", "Soul verdicts inform Mind admission; they do not mutate repo or state by themselves.", ], ), mutation_contract( SOUL_INVARIANT_CHECK_TYPE, SOUL_INVARIANT_CHECK_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Invariant checks identify which promise was tested and whether old paths can still violate it.", ], ), mutation_contract( SOUL_VERDICT_RECEIPT_TYPE, SOUL_VERDICT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Verdict receipts are proof of sanctity or proof of failure."], ), mutation_contract( SOUL_REGRESSION_RECEIPT_TYPE, SOUL_REGRESSION_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Regression receipts preserve violated invariants and surviving obsolete authorities.", ], ), mutation_contract( SOUL_REVIEW_RECEIPT_TYPE, SOUL_REVIEW_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Review receipts preserve risks, missing tests, and falsification notes."], ), mutation_contract( SOUL_VERIFICATION_REFUSAL_RECEIPT_TYPE, SOUL_VERIFICATION_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Soul refusal receipts preserve why a verification request could not honestly be performed.", ], ), mutation_contract( CONTINUITY_PACKET_TYPE, CONTINUITY_PACKET_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![CONTINUITY_PACKET_TYPE], vec![ CONTINUITY_COMPACTION_CHECKPOINT_TYPE, CONTINUITY_SLEEP_DISTILLATION_TYPE, CONTINUITY_RECOVERY_RECEIPT_TYPE, CONTINUITY_STALE_TURN_REPAIR_TYPE, CONTINUITY_REFUSAL_RECEIPT_TYPE, ], vec![ "Continuity is deterministic protocol machinery: compaction, sleep, recovery, stale-turn repair, and handoff packets enter here.", "Continuity preserves survival across rupture; Mind admits durable state.", ], ), mutation_contract( CONTINUITY_COMPACTION_CHECKPOINT_TYPE, CONTINUITY_COMPACTION_CHECKPOINT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Compaction checkpoints preserve hot context before rupture."], ), mutation_contract( CONTINUITY_SLEEP_DISTILLATION_TYPE, CONTINUITY_SLEEP_DISTILLATION_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Sleep distillation receipts separate durable lessons from rumination residue."], ), mutation_contract( CONTINUITY_RECOVERY_RECEIPT_TYPE, CONTINUITY_RECOVERY_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Recovery receipts explain what survived and what must be regathered."], ), mutation_contract( CONTINUITY_STALE_TURN_REPAIR_TYPE, CONTINUITY_STALE_TURN_REPAIR_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Stale-turn repair receipts close abandoned work without pretending it completed.", ], ), mutation_contract( CONTINUITY_REFUSAL_RECEIPT_TYPE, CONTINUITY_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Continuity refusal receipts preserve why a continuity packet could not be trusted.", ], ), mutation_contract( RUNTIME_EVENT_TYPE, RUNTIME_SPINE_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Runtime events are append-only projections for inspection."], ), mutation_contract( COORDINATOR_RUN_RECEIPT_TYPE, COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::Coordinator, vec![], vec![], vec![ "Coordinator run receipts are typed summaries of local plan/run decisions; artifact JSON is display evidence, not the only durable account.", ], ), mutation_contract( MODEL_ADAPTER_STATUS_TYPE, MODEL_ADAPTER_STATUS_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Model adapter status is provider-neutral; OpenAI/Codex is one current provider behind this boundary.", ], ), mutation_contract( MODEL_REQUEST_TYPE, MODEL_REQUEST_SCHEMA_VERSION, vec![ CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![MODEL_REQUEST_TYPE], vec![MODEL_STREAM_EVENT_TYPE, MODEL_RECEIPT_TYPE], vec![ "Model turns enter through typed provider-neutral Epiphany request documents and return typed stream events/receipts.", "Provider adapters may authenticate and transport; they must not own Epiphany state, prompt authority, or scheduling.", ], ), mutation_contract( MODEL_STREAM_EVENT_TYPE, MODEL_STREAM_EVENT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Model stream events are receipts from a typed model request."], ), mutation_contract( MODEL_RECEIPT_TYPE, MODEL_RECEIPT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Terminal model receipts carry provider response id, usage, and transport evidence.", ], ), mutation_contract( TOOL_CAPABILITY_TYPE, TOOL_CAPABILITY_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Tool capability documents describe adapter-discovered tools without making raw MCP discovery JSON authoritative.", ], ), mutation_contract( TOOL_INVOCATION_INTENT_TYPE, TOOL_INVOCATION_INTENT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![TOOL_INVOCATION_INTENT_TYPE], vec![TOOL_INVOCATION_RECEIPT_TYPE], vec![ "Tool calls enter Epiphany as typed invocation intents; MCP JSON remains protocol-edge cargo.", ], ), mutation_contract( TOOL_INVOCATION_RECEIPT_TYPE, TOOL_INVOCATION_RECEIPT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "Tool invocation receipts seal parsed results, errors, and raw-result artifact refs before scheduler or state admission.", ], ), mutation_contract( OPENAI_ADAPTER_STATUS_TYPE, OPENAI_ADAPTER_STATUS_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "OpenAI adapter status is provider-specific evidence behind the model adapter boundary.", ], ), mutation_contract( OPENAI_MODEL_REQUEST_TYPE, OPENAI_MODEL_REQUEST_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![OPENAI_MODEL_STREAM_EVENT_TYPE, OPENAI_MODEL_RECEIPT_TYPE], vec![ "OpenAI model requests are adapter projection evidence, not the provider-neutral request authority.", ], ), mutation_contract( OPENAI_MODEL_STREAM_EVENT_TYPE, OPENAI_MODEL_STREAM_EVENT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "OpenAI stream events are provider-specific receipts mirrored from model stream events.", ], ), mutation_contract( OPENAI_MODEL_RECEIPT_TYPE, OPENAI_MODEL_RECEIPT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "OpenAI terminal receipts are provider-specific evidence behind the model receipt.", ], ), mutation_contract( AGENT_MEMORY_TYPE, AGENT_MEMORY_PAYLOAD_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec!["epiphany.agent_memory_intent.v0"], vec!["epiphany.swarm_control_receipt.v0"], vec![ "Sub-agents request memory mutations; the coordinator carries the typed intent, and Mind accepts, rejects, or explains durable-state admission.", ], ), mutation_contract( HEARTBEAT_STATE_TYPE, HEARTBEAT_STATE_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, vec![ "epiphany.heartbeat_pump_intent.v0", "epiphany.heartbeat_heat_intent.v0", "epiphany.circadian_rhythm_intent.v0", ], vec!["epiphany.swarm_control_receipt.v0"], vec![ "Aquarium controls heartbeat and circadian rhythm through typed intents, not blind state replacement.", "Initiative heat is heartbeat policy: global, group, role, and agent tempo changes enter through the heartbeat heat intent.", ], ), mutation_contract( STATE_LEDGER_STORE_TYPE, STATE_LEDGER_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "The ledger is inspected as durable memory; writes are mediated by role-specific state flows.", ], ), mutation_contract( THREAD_STATE_TYPE, THREAD_STATE_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "The mirrored thread state is the typed repo/control-plane state source; Codex rollout is a compatibility source, not the network contract.", ], ), mutation_contract( MEMORY_GRAPH_TYPE, MEMORY_GRAPH_SCHEMA_VERSION, vec![CultNetDocumentOperation::Snapshot], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec![ "The unified memory graph is typed durable state; Qdrant embeddings are rebuildable cache, not canonical memory.", ], ), mutation_contract( REPO_MODEL_ADMISSION_REVIEW_TYPE, REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION, vec![CultNetDocumentOperation::DocumentPut], CultNetMutationAuthority::Runtime, vec![], vec![REPO_MODEL_ADMISSION_RECEIPT_TYPE], vec![ "Specialized Mind review binds one immutable Modeling result and exact repo-model patch.", ], ), mutation_contract( REPO_MODEL_ADMISSION_RECEIPT_TYPE, REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Admission receipt proves the conditional model/review/receipt commit."], ), mutation_contract( REPO_MODEL_MIGRATION_RECEIPT_TYPE, REPO_MODEL_MIGRATION_RECEIPT_SCHEMA_VERSION, vec![CultNetDocumentOperation::ReceiptWatch], CultNetMutationAuthority::ReadOnly, vec![], vec![], vec!["Migration receipt proves the one-time move into runtime-owned model state."], ), mutation_contract( EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE, EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::DocumentPut, ], CultNetMutationAuthority::LocalUser, vec![], vec![], vec![ "Operator snapshots are bounded typed receipts derived from operator-safe status/run artifacts.", "Raw Codex app-server JSON remains an edge artifact; this CultMesh document is the native Epiphany status receipt.", ], ), mutation_contract( EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE, EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::DocumentPut, ], CultNetMutationAuthority::LocalUser, vec![], vec![EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE], vec![ "Operator run intents record explicit local wrapper requests before status/plan/smoke/run actions execute.", "This is not a scheduler queue; it is the typed consent/trace surface for local operator action.", ], ), mutation_contract( EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE, EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::DocumentPut, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::LocalUser, vec![], vec![], vec![ "Operator run receipts record completed local wrapper actions and evidence artifact references.", "Referenced artifacts remain evidence; the receipt is the native completion contract.", ], ), ] } fn validate_non_empty(value: &str, field: &str) -> Result<()> { if value.trim().is_empty() { return Err(anyhow!("{field} must be non-empty")); } Ok(()) } fn timestamp_after(value: &str, lower_bound: &str) -> bool { !value.trim().is_empty() && value > lower_bound } fn worker_launch_document_kind(document: &EpiphanyWorkerLaunchDocument) -> &'static str { document.document_kind() } fn encode_worker_launch_document(document: &EpiphanyWorkerLaunchDocument) -> Result> { rmp_serde::to_vec_named(document).context("failed to encode worker launch document MessagePack") } fn validate_launch_organ_contract( contract: &EpiphanyLaunchOrganContract, authority_scope: &str, document_kind: &str, output_contract_id: &str, ) -> Result<()> { validate_non_empty( &contract.schema_version, "epiphany launch organ contract schema_version", )?; if contract.authority_scope != authority_scope { return Err(anyhow!( "epiphany launch organ contract authority_scope must match the launch request" )); } if contract.document_kind != document_kind { return Err(anyhow!( "epiphany launch organ contract document_kind must match the typed launch document" )); } if contract.output_contract_id != output_contract_id { return Err(anyhow!( "epiphany launch organ contract output_contract_id must match the launch request" )); } validate_non_empty( &contract.owner_organ, "epiphany launch organ contract owner_organ", )?; if contract.dependencies.is_empty() { return Err(anyhow!( "epiphany launch organ contract must carry organ dependencies" )); } if contract.required_receipt_document_types.is_empty() { return Err(anyhow!( "epiphany launch organ contract must carry required receipt document types" )); } if contract.receipt_proof_profiles.is_empty() { return Err(anyhow!( "epiphany launch organ contract must carry effect-specific receipt proof profiles" )); } Ok(()) } fn decode_optional_msgpack(payload: Option<&[u8]>, label: &str) -> Result> where T: for<'de> Deserialize<'de>, { payload .map(|payload| { rmp_serde::from_slice(payload).with_context(|| format!("failed to decode {label}")) }) .transpose() } fn validate_heartbeat_launch_options( state: &EpiphanyThreadState, options: &RuntimeSpineHeartbeatLaunchPlanOptions, ) -> Result<()> { validate_non_empty(&options.binding_id, "epiphany job launch binding_id")?; if matches!( options.binding_id.as_str(), "retrieval-index" | "graph-remap" | "verification" ) { return Err(anyhow!( "epiphany job launch binding_id {:?} is reserved for a derived built-in slot", options.binding_id )); } if options.kind != EpiphanyJobKind::Specialist { return Err(anyhow!( "epiphany job launch currently supports only specialist heartbeat turns" )); } validate_non_empty(&options.scope, "epiphany job launch scope")?; validate_non_empty(&options.owner_role, "epiphany job launch owner_role")?; validate_non_empty( &options.authority_scope, "epiphany job launch authority_scope", )?; validate_non_empty(&options.instruction, "epiphany job launch instruction")?; validate_non_empty( options.launch_document.thread_id(), "epiphany job launch document thread id", )?; validate_non_empty( &options.output_contract_id, "epiphany job launch output_contract_id", )?; if options.output_contract_id != options.launch_document.output_contract_id() { return Err(anyhow!( "epiphany job launch output_contract_id must match the typed launch document" )); } validate_launch_organ_contract( &options.organ_launch_contract, &options.authority_scope, options.launch_document.document_kind(), &options.output_contract_id, )?; if let Some(max_runtime_seconds) = options.max_runtime_seconds && max_runtime_seconds == 0 { return Err(anyhow!( "epiphany job launch max_runtime_seconds must be >= 1" )); } let existing_binding = state .job_bindings .iter() .find(|binding| binding.id == options.binding_id); let latest_runtime_link = state.runtime_links.iter().find(|link| { link.binding_id == options.binding_id && !link.runtime_job_id.trim().is_empty() }); if latest_runtime_link.is_some_and(|link| link.runtime_result_id.is_none()) && existing_binding.is_none_or(|binding| binding.blocking_reason.is_none()) { return Err(anyhow!( "epiphany job binding {:?} is already bound to an active heartbeat turn; interrupt it before launching a replacement", options.binding_id )); } Ok(()) } fn terminal_status_for_verdict(verdict: &str) -> EpiphanyRuntimeJobStatus { if matches!( verdict, "failed" | "fail" | "error" | "blocked" | "cancelled" | "canceled" ) { EpiphanyRuntimeJobStatus::Failed } else { EpiphanyRuntimeJobStatus::Completed } } fn merge_refs(existing: &[String], incoming: &[String]) -> Vec { let mut merged = existing.to_vec(); for item in incoming { if !merged.contains(item) { merged.push(item.clone()); } } merged } #[cfg(test)] pub(crate) mod tests { use super::*; use cultnet_rs::CultNetWireContract; use cultnet_rs::decode_cultnet_message_from_slice; use tempfile::tempdir; fn repo_model_bootstrap() -> crate::EpiphanyMemoryGraphSnapshot { crate::EpiphanyMemoryGraphSnapshot { schema_version: Some(crate::MEMORY_GRAPH_SCHEMA_VERSION.to_string()), graph_id: "runtime-repo-model".to_string(), domains: vec![crate::EpiphanyMemoryDomain { id: "repo".to_string(), profile: crate::EpiphanyMemoryProfile::RepoArchitecture, title: "Repository".to_string(), lifecycle: crate::EpiphanyMemoryLifecycle::Accepted, ..Default::default() }], nodes: vec![crate::EpiphanyMemoryNode { id: "claim-runtime-model".to_string(), domain_id: "repo".to_string(), profile: crate::EpiphanyMemoryProfile::RepoArchitecture, kind: crate::EpiphanyMemoryNodeKind::RuntimeContract, title: "Runtime model".to_string(), claim: "Runtime spine owns admitted repository model state.".to_string(), question: "Which patch is admitted next?".to_string(), action_implication: "Require specialized Mind admission.".to_string(), source_hashes: vec!["anchor:missing".to_string()], lifecycle: crate::EpiphanyMemoryLifecycle::Accepted, ..Default::default() }], ..Default::default() } } pub(crate) fn bind_test_runtime_swarm(store: &Path, swarm_id: &str) -> Result<()> { let agent_store = store.with_extension("test-agent-memory.cc"); crate::ensure_agent_memory_swarm_identity(&agent_store, swarm_id)?; bind_runtime_to_agent_memory_swarm(store, &agent_store, "2026-07-13T00:00:01Z")?; Ok(()) } pub(crate) fn bind_test_repository_body(store: &Path, workspace_id: &str) -> Result<()> { if crate::runtime_repository_body_store_binding(store)?.is_some() { return Ok(()); } let repo = store.with_extension(format!("{workspace_id}.body-repo")); std::fs::create_dir_all(&repo)?; let init = std::process::Command::new("git") .args(["init", "--quiet"]) .current_dir(&repo) .output()?; if !init.status.success() { return Err(anyhow!("test repository git init failed")); } std::fs::write(repo.join("body-seed.txt"), workspace_id.as_bytes())?; let add = std::process::Command::new("git") .args(["add", "body-seed.txt"]) .current_dir(&repo) .output()?; if !add.status.success() { return Err(anyhow!("test repository git add failed")); } let body_store = store.with_extension(format!("{workspace_id}.body.cc")); crate::bind_repository_body(&repo, &body_store, store, workspace_id)?; Ok(()) } fn put_test_non_modeling_worker_launch(store: &Path, job_id: &str, role: &str) -> Result<()> { let document = EpiphanyWorkerLaunchDocument::Role(crate::EpiphanyRoleWorkerLaunchDocument { thread_id: format!("fixture-thread-{job_id}"), role_id: role.to_string(), state_revision: 0, objective: Some(format!("Fixture {role} launch")), dynamic_prompt_context: None, repository_body_observation_basis: None, proposal_modeling_context: None, claim_repair_context: None, frontier_planning_context: None, frontier_plan_mind_context: None, imagination_consideration_context: None, admitted_model_direction_consideration_context: None, active_subgoal_id: None, active_subgoals: Vec::new(), active_graph_node_ids: Vec::new(), investigation_checkpoint: None, scratch: None, invariants: Vec::new(), graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, graph_checkpoint: None, planning: None, churn: None, }); let request = EpiphanyRuntimeWorkerLaunchRequest { schema_version: RUNTIME_WORKER_LAUNCH_REQUEST_SCHEMA_VERSION.to_string(), job_id: job_id.to_string(), binding_id: format!("{role}-worker"), role: role.to_string(), authority_scope: role.to_string(), instruction: format!("Fixture {role} instruction"), output_contract_id: crate::ROLE_WORKER_OUTPUT_CONTRACT_ID.to_string(), document_kind: worker_launch_document_kind(&document).to_string(), launch_document_msgpack: encode_worker_launch_document(&document)?, metadata: BTreeMap::new(), organ_launch_contract: crate::default_launch_organ_contract( role, "role", crate::ROLE_WORKER_OUTPUT_CONTRACT_ID, ), proposal_modeling_request_id: None, claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_mind_request_id: None, imagination_consideration_request_id: None, admitted_model_direction_consideration_request_id: None, }; let mut cache = runtime_spine_cache(store)?; cache.put(job_id, &request)?; Ok(()) } #[test] fn legacy_repo_model_migration_adds_only_exact_projection_pressure() -> Result<()> { let root = tempdir()?; let store = root.path().join("legacy-repo-model.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "legacy-runtime".into(), display_name: "Legacy runtime".into(), created_at: "2026-07-15T00:00:00Z".into(), }, )?; bind_test_runtime_swarm(&store, "legacy-swarm")?; let snapshot = repo_model_bootstrap(); let entry = crate::EpiphanyMemoryGraphEntry::from_snapshot(&snapshot)?; let model_hash = crate::memory_graph_model_hash(&snapshot)?; let receipt = RepoModelMigrationReceipt { schema_version: REPO_MODEL_MIGRATION_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: "repo-model-migration".into(), source_store: "legacy-test".into(), source_graph_id: snapshot.graph_id.clone(), imported_revision: snapshot.model_revision, imported_hash: model_hash, imported_at: "2026-07-15T00:00:01Z".into(), contract: REPO_MODEL_MIGRATION_CONTRACT.to_string(), }; let mut cache = runtime_spine_cache(&store)?; cache.put(crate::MEMORY_GRAPH_KEY, &entry)?; cache.put(&receipt.receipt_id, &receipt)?; let obligation = migrate_legacy_repo_model_projection_obligation(&store)? .expect("legacy projection obligation"); assert_eq!(obligation.source_commit_id, receipt.receipt_id); assert_eq!(obligation.source_generation, snapshot.model_revision); assert_eq!(obligation.partition, "modeling"); assert_eq!( migrate_legacy_repo_model_projection_obligation(&store)?, Some(obligation.clone()) ); assert_eq!(runtime_current_repo_model(&store)?, Some(snapshot.clone())); let input = runtime_modeling_semantic_projection_input(&store)?; assert_eq!(input.snapshot, snapshot); assert_eq!(input.obligation, obligation); assert_eq!(input.authority.envelopes.len(), 2); Ok(()) } fn repo_model_result_and_review( store: &Path, result_id: &str, job_id: &str, current: &crate::EpiphanyMemoryGraphSnapshot, review_id: &str, ) -> Result<(EpiphanyRuntimeRoleWorkerResult, RepoModelAdmissionReview)> { let mut cache = runtime_spine_cache(store)?; cache.pull_all_backing_stores()?; let identity = require_identity(&cache)?; let thread_id = format!("fixture-thread-{result_id}"); let state = epiphany_state_model::EpiphanyThreadState::default(); cache.put( crate::THREAD_STATE_KEY, &crate::EpiphanyThreadStateEntry::from_state(&thread_id, &state)?, )?; let proposal_id = format!("proposal-{result_id}"); intake_user_repo_frontier_proposal( store, crate::RepoFrontierUserProposalInput { proposal_id: proposal_id.clone(), source_actor: "fixture-user".into(), source_ref: format!("fixture:{result_id}"), repository: "EpiphanyAgent".into(), workspace: "E:/Projects/EpiphanyAgent".into(), thread_id: thread_id.clone(), runtime_id: identity.runtime_id, title: format!("Frontier seed {result_id}"), body: "Typed fixture proposal".into(), desired_outcome: "One contestable frontier contribution".into(), constraints: vec!["No direct Hands authority".into()], scope_hints: vec!["epiphany-core/src/runtime_spine.rs".into()], evidence_refs: vec![format!("evidence-{result_id}")], private_state_included: false, proposed_at: "2026-07-13T03:59:58Z".into(), }, )?; let selection = select_repo_frontier_work_proposal_for_modeling( store, &proposal_id, "2026-07-13T03:59:59Z", )?; let mut launch = crate::build_epiphany_role_launch_request( &thread_id, crate::EpiphanyRoleResultRoleId::Modeling, Some(state.revision), Some(60), &state, ) .map_err(|error| anyhow!(error))?; launch.proposal_modeling_request_id = Some(selection.request_id.clone()); let plan = crate::plan_coordinator_job_launch( &state, &launch, store, format!("launcher-{job_id}"), job_id.to_string(), )?; bind_test_repository_body(store, &format!("workspace-{result_id}"))?; crate::commit_coordinator_job_launch( store, &thread_id, &state, &launch, &plan, "2026-07-13T04:00:00Z".into(), )?; let patch = crate::RepoModelPatch { patch_id: format!("patch-{result_id}"), base_revision: current.model_revision, base_hash: crate::memory_graph_model_hash(current)?, applied_at: "2026-07-13T04:00:00Z".to_string(), purpose: crate::RepoModelPatchPurpose::Evolution, operations: vec![crate::RepoModelPatchOperation::UpsertFrontier { item: crate::RepoFrontierItem { id: format!("frontier-{result_id}"), migration_body: "Carry admitted Modeling anatomy forward.".to_string(), question: "Does the specialized review bind this patch?".to_string(), gap: "Generic acceptance cannot own repository anatomy.".to_string(), target_claim_ids: vec!["claim-runtime-model".to_string()], source_scope: vec!["epiphany-core/src/runtime_spine.rs".to_string()], recommended_next_organ: "Hands".to_string(), evidence_refs: vec![proposal_id.clone()], status: crate::RepoFrontierStatus::Active, ..Default::default() }, }], }; let patch_bytes = rmp_serde::to_vec_named(&patch)?; let result = EpiphanyRuntimeRoleWorkerResult { schema_version: RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.to_string(), repository_body_observation_basis: runtime_worker_launch_body_basis(store, job_id)?, result_id: result_id.to_string(), job_id: job_id.to_string(), role_id: "modeling".to_string(), verdict: "checkpoint-ready".to_string(), summary: "Proposed a typed repository model patch.".to_string(), next_safe_move: "Mind review.".to_string(), checkpoint_summary: None, scratch_summary: None, files_inspected: vec!["epiphany-core/src/runtime_spine.rs".to_string()], frontier_node_ids: vec!["claim-runtime-model".to_string()], evidence_ids: vec![proposal_id], artifact_refs: Vec::new(), open_questions: Vec::new(), evidence_gaps: Vec::new(), risks: Vec::new(), state_patch_msgpack: None, self_patch_msgpack: None, item_error: None, metadata: BTreeMap::new(), repo_model_patch_msgpack: Some(patch_bytes.clone()), verification_request_id: None, frontier_route_id: None, repo_frontier_modeling_request_id: None, proposal_modeling_request_id: Some(selection.request_id), claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_candidate_msgpack: None, frontier_plan_mind_request_id: None, frontier_plan_mind_decision_msgpack: None, imagination_consideration_request_id: None, imagination_consideration_candidate_msgpack: None, admitted_model_direction_consideration_request_id: None, admitted_model_direction_consideration_result_msgpack: None, }; let review = RepoModelAdmissionReview { schema_version: REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION.to_string(), review_id: review_id.to_string(), result_id: Some(result_id.to_string()), job_id: Some(job_id.to_string()), patch_id: patch.patch_id, patch_sha256: format!("{:x}", Sha256::digest(&patch_bytes)), base_revision: patch.base_revision, base_hash: patch.base_hash, decision: MindGatewayDecision::Accept, evidence_ids: result.evidence_ids.clone(), reviewed_at: "2026-07-13T04:00:01Z".to_string(), contract: REPO_MODEL_ADMISSION_CONTRACT.to_string(), repository_body_observation_basis: result.repository_body_observation_basis.clone(), admission_source: Some(crate::RepoModelAdmissionSource::WorkerResult { result_id: result_id.to_string(), job_id: job_id.to_string(), }), }; Ok((result, review)) } #[test] fn modeling_result_ingress_requires_the_exact_immutable_launch_body_basis() -> Result<()> { for mutation in ["missing", "swapped"] { let root = tempdir()?; let store = root.path().join(format!("body-basis-{mutation}.cc")); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: format!("body-basis-runtime-{mutation}"), display_name: "Body basis ingress".into(), created_at: "2026-07-15T00:00:00Z".into(), }, )?; bind_test_runtime_swarm(&store, &format!("body-basis-swarm-{mutation}"))?; let bootstrap = repo_model_bootstrap(); let legacy = root.path().join(format!("body-basis-{mutation}.legacy")); let (current, _) = ensure_runtime_repo_model(&store, &legacy, &bootstrap, "2026-07-15T00:00:01Z")?; let (mut result, _) = repo_model_result_and_review( &store, &format!("body-basis-result-{mutation}"), &format!("body-basis-job-{mutation}"), ¤t, &format!("body-basis-review-{mutation}"), )?; match mutation { "missing" => result.repository_body_observation_basis = None, "swapped" => { result .repository_body_observation_basis .as_mut() .expect("fixture Modeling basis") .observation_id = "counterfeit-observation".into(); } _ => unreachable!(), } let before = std::fs::read(&store)?; assert!(put_runtime_role_worker_result(&store, &result).is_err()); assert_eq!(std::fs::read(&store)?, before); } Ok(()) } #[test] fn repo_model_admission_refuses_review_body_substitution_without_writes() -> Result<()> { let root = tempdir()?; let (store, result, mut review) = proposal_admission_fixture(root.path(), "body-swap")?; put_runtime_role_worker_result(&store, &result)?; review .repository_body_observation_basis .as_mut() .expect("Modeling review basis") .manifest_root_sha256 = "counterfeit-root".into(); let before = std::fs::read(&store)?; assert!(commit_repo_model_admission(&store, &result.result_id, &review).is_err()); assert_eq!(std::fs::read(&store)?, before); Ok(()) } #[test] fn repo_model_admission_preserves_valid_historical_body_basis() -> Result<()> { let root = tempdir()?; let (store, result, review) = proposal_admission_fixture(root.path(), "historical-body")?; put_runtime_role_worker_result(&store, &result)?; let original = review .repository_body_observation_basis .clone() .expect("Modeling review basis"); let route = crate::runtime_repository_body_store_binding(&store)?.expect("runtime Body route"); let body_store = PathBuf::from(route.body_store_path); let (binding, _) = crate::load_repository_body_status(&body_store)?.expect("repository Body status"); std::fs::write( Path::new(&binding.git_top_level).join("body-seed.txt"), b"changed after Modeling launch", )?; let add = std::process::Command::new("git") .args(["add", "body-seed.txt"]) .current_dir(&binding.git_top_level) .output()?; assert!(add.status.success()); let changed = match crate::observe_repository_body( Path::new(&binding.git_top_level), &body_store, &store, )? { crate::ObserveOutcome::Created(value) | crate::ObserveOutcome::Unchanged(value) => { value } }; assert_ne!(changed.manifest_root_sha256, original.manifest_root_sha256); let receipt = commit_repo_model_admission(&store, &result.result_id, &review)?; assert_eq!(receipt.repository_body_observation_basis, Some(original)); Ok(()) } fn proposal_admission_fixture( root: &Path, suffix: &str, ) -> Result<( PathBuf, EpiphanyRuntimeRoleWorkerResult, RepoModelAdmissionReview, )> { let store = root.join(format!("proposal-admission-{suffix}.cc")); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: format!("proposal-runtime-{suffix}"), display_name: "Proposal admission fixture".into(), created_at: "2026-07-13T03:00:00Z".into(), }, )?; bind_test_runtime_swarm(&store, &format!("proposal-swarm-{suffix}"))?; let bootstrap = repo_model_bootstrap(); let legacy = root.join(format!("proposal-{suffix}.legacy")); let (current, _) = ensure_runtime_repo_model(&store, &legacy, &bootstrap, "2026-07-13T03:30:00Z")?; let (result, review) = repo_model_result_and_review( &store, &format!("proposal-result-{suffix}"), &format!("proposal-job-{suffix}"), ¤t, &format!("proposal-review-{suffix}"), )?; Ok((store, result, review)) } fn claim_repair_admission_fixture( root: &Path, suffix: &str, ) -> Result<( PathBuf, EpiphanyRuntimeRoleWorkerResult, RepoModelAdmissionReview, RepoModelClaimRepairRequest, )> { let (store, state, launch, repair) = crate::coordinator_launch::tests::claim_repair_launch_fixture(root, suffix)?; let job_id = format!("claim-repair-job-{suffix}"); let plan = crate::plan_coordinator_job_launch( &state, &launch, &store, format!("claim-repair-launcher-{suffix}"), job_id.clone(), )?; crate::commit_coordinator_job_launch( &store, &repair.thread_id, &state, &launch, &plan, "2026-07-14T09:00:03Z".into(), )?; let current = runtime_current_repo_model(&store)?.expect("claim repair model"); let mut node = current .nodes .iter() .find(|node| node.id == repair.target_claim_id) .cloned() .expect("challenged node"); node.claim = format!("{} Corrected by exact Eyes evidence.", node.claim); node.updated_at = Some("2026-07-14T09:00:04Z".into()); let patch = crate::RepoModelPatch { patch_id: format!("claim-repair-patch-{suffix}"), base_revision: current.model_revision, base_hash: crate::memory_graph_model_hash(¤t)?, applied_at: "2026-07-14T09:00:04Z".into(), purpose: crate::RepoModelPatchPurpose::RepairClaim, operations: vec![crate::RepoModelPatchOperation::ReviseNode { node }], }; let patch_bytes = rmp_serde::to_vec_named(&patch)?; let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let challenge = cache.get_required::(&repair.challenge_id)?; let mut evidence_ids = challenge.evidence_ids.clone(); evidence_ids.push(challenge.challenge_id); evidence_ids.push(repair.eyes_evidence_packet_id.clone()); evidence_ids.sort(); evidence_ids.dedup(); let result = EpiphanyRuntimeRoleWorkerResult { schema_version: RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.into(), repository_body_observation_basis: runtime_worker_launch_body_basis(&store, &job_id)?, result_id: format!("claim-repair-result-{suffix}"), job_id, role_id: "modeling".into(), verdict: "checkpoint-ready".into(), summary: "Proposed the exact challenged claim correction.".into(), next_safe_move: "Mind admission".into(), checkpoint_summary: None, scratch_summary: None, files_inspected: Vec::new(), frontier_node_ids: vec![repair.target_claim_id.clone()], evidence_ids: evidence_ids.clone(), artifact_refs: Vec::new(), open_questions: Vec::new(), evidence_gaps: Vec::new(), risks: Vec::new(), state_patch_msgpack: None, self_patch_msgpack: None, item_error: None, metadata: BTreeMap::new(), repo_model_patch_msgpack: Some(patch_bytes.clone()), verification_request_id: None, frontier_route_id: None, repo_frontier_modeling_request_id: None, proposal_modeling_request_id: None, claim_repair_request_id: Some(repair.request_id.clone()), frontier_planning_request_id: None, frontier_plan_candidate_msgpack: None, frontier_plan_mind_request_id: None, frontier_plan_mind_decision_msgpack: None, imagination_consideration_request_id: None, imagination_consideration_candidate_msgpack: None, admitted_model_direction_consideration_request_id: None, admitted_model_direction_consideration_result_msgpack: None, }; let review = RepoModelAdmissionReview { schema_version: REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION.into(), review_id: format!("claim-repair-review-{suffix}"), result_id: Some(result.result_id.clone()), job_id: Some(result.job_id.clone()), patch_id: patch.patch_id, patch_sha256: format!("{:x}", Sha256::digest(&patch_bytes)), base_revision: patch.base_revision, base_hash: patch.base_hash, decision: MindGatewayDecision::Accept, evidence_ids, reviewed_at: "2026-07-14T09:00:05Z".into(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), repository_body_observation_basis: result.repository_body_observation_basis.clone(), admission_source: Some(crate::RepoModelAdmissionSource::WorkerResult { result_id: result.result_id.clone(), job_id: result.job_id.clone(), }), }; Ok((store, result, review, repair)) } #[test] fn claim_repair_admission_replays_launch_and_changes_only_the_challenged_node() -> Result<()> { let root = tempfile::tempdir()?; let (store, result, review, repair) = claim_repair_admission_fixture(root.path(), "admit")?; put_runtime_role_worker_result(&store, &result)?; let receipt = commit_repo_model_admission(&store, &result.result_id, &review)?; assert_eq!(receipt.claim_repair_request_id, repair.request_id); assert_eq!(receipt.purpose, crate::RepoModelPatchPurpose::RepairClaim); assert_eq!( commit_repo_model_admission(&store, &result.result_id, &review)?, receipt ); let current = runtime_current_repo_model(&store)?.expect("repaired model"); let repaired = current .nodes .iter() .find(|node| node.id == repair.target_claim_id) .expect("repaired claim remains present"); assert_ne!( format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(repaired)?)), repair.target_claim_sha256 ); let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let current_hash = crate::memory_graph_model_hash(¤t)?; assert!(current_repo_model_claim_challenges(&cache, ¤t, ¤t_hash)?.is_empty()); Ok(()) } #[test] fn claim_repair_admission_refuses_substitution_without_model_writes() -> Result<()> { for mutation in [ "swapped-request", "missing-evidence", "extra-operation", "wrong-target", "unchanged-claim", "timestamp-only", "identity-mutation", "lifecycle-mutation", "state-patch-smuggling", "self-patch-smuggling", "launch-hash", "counterfeit-retry-receipt", ] { let root = tempfile::tempdir()?; let (store, mut result, mut review, repair) = claim_repair_admission_fixture(root.path(), mutation)?; match mutation { "swapped-request" => { result.claim_repair_request_id = Some("adjacent-repair-request".into()) } "missing-evidence" => { result.evidence_ids.pop(); review.evidence_ids = result.evidence_ids.clone(); } "launch-hash" => { let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let key = format!("repo-model-claim-repair-launch-{}", repair.request_id); let mut binding = cache.get_required::(&key)?; binding.worker_launch_document_sha256 = "00".repeat(32); overwrite_test_entry(&store, &key, &binding)?; } "state-patch-smuggling" => { result.state_patch_msgpack = Some(vec![0x80]); } "self-patch-smuggling" => { result.self_patch_msgpack = Some(vec![0x80]); } "counterfeit-retry-receipt" => { overwrite_test_entry(&store, &review.review_id, &review)?; let receipt_id = format!("repo-model-admission-{}", review.review_id); overwrite_test_entry( &store, &receipt_id, &RepoModelAdmissionReceipt { schema_version: REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION.into(), receipt_id: receipt_id.clone(), review_id: review.review_id.clone(), result_id: Some(result.result_id.clone()), patch_id: review.patch_id.clone(), patch_sha256: review.patch_sha256.clone(), previous_revision: repair.model_revision, previous_hash: repair.model_hash.clone(), admitted_revision: repair.model_revision + 1, admitted_hash: "counterfeit-admitted-hash".into(), admitted_at: review.reviewed_at.clone(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), purpose: crate::RepoModelPatchPurpose::RepairClaim, frontier_route_id: String::new(), verification_request_id: String::new(), soul_verdict_receipt_id: String::new(), frontier_modeling_request_id: String::new(), proposal_modeling_request_id: String::new(), claim_repair_request_id: repair.request_id.clone(), frontier_plan_decision_id: String::new(), repository_body_observation_basis: review .repository_body_observation_basis .clone(), admission_source: review.admission_source.clone(), }, )?; } _ => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let current = runtime_current_repo_model(&store)?.expect("current model"); let current_node = current .nodes .iter() .find(|node| node.id == repair.target_claim_id) .cloned() .expect("challenged node"); match mutation { "extra-operation" => patch.operations.push(patch.operations[0].clone()), "wrong-target" => { let crate::RepoModelPatchOperation::ReviseNode { node } = &mut patch.operations[0] else { unreachable!() }; node.id = "wrong-target-claim".into(); } "unchanged-claim" => { patch.operations[0] = crate::RepoModelPatchOperation::ReviseNode { node: current_node }; } "timestamp-only" => { let mut timestamp_only = current_node; timestamp_only.updated_at = Some("2026-07-14T09:00:04Z".into()); patch.operations[0] = crate::RepoModelPatchOperation::ReviseNode { node: timestamp_only, }; } "identity-mutation" => { let crate::RepoModelPatchOperation::ReviseNode { node } = &mut patch.operations[0] else { unreachable!() }; node.domain_id = "other-domain".into(); } "lifecycle-mutation" => { let crate::RepoModelPatchOperation::ReviseNode { node } = &mut patch.operations[0] else { unreachable!() }; node.lifecycle = crate::EpiphanyMemoryLifecycle::Retired; } _ => unreachable!(), } let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_id = patch.patch_id; review.patch_sha256 = format!("{:x}", Sha256::digest(&bytes)); review.base_revision = patch.base_revision; review.base_hash = patch.base_hash; } } if matches!(mutation, "state-patch-smuggling" | "self-patch-smuggling") { let before = std::fs::read(&store)?; assert!( put_runtime_role_worker_result(&store, &result).is_err(), "mutation {mutation} must be refused at immutable result ingestion" ); assert_eq!(std::fs::read(&store)?, before); continue; } put_runtime_role_worker_result(&store, &result)?; let before = std::fs::read(&store)?; assert!( commit_repo_model_admission(&store, &result.result_id, &review).is_err(), "mutation {mutation} must be refused" ); assert_eq!( std::fs::read(&store)?, before, "mutation {mutation} wrote partial admission state" ); } Ok(()) } fn assert_proposal_admission_refused_without_state_mutation( store: &Path, result: &EpiphanyRuntimeRoleWorkerResult, review: &RepoModelAdmissionReview, ) -> Result<()> { put_runtime_role_worker_result(store, result)?; let before = std::fs::read(store)?; assert!(commit_repo_model_admission(store, &result.result_id, review).is_err()); assert_eq!(std::fs::read(store)?, before); Ok(()) } #[test] fn role_worker_result_is_absent_only_with_exact_retry() -> Result<()> { let root = tempfile::tempdir()?; let (store, result, _) = proposal_admission_fixture(root.path(), "immutable-result")?; put_runtime_role_worker_result(&store, &result)?; let after_first = std::fs::read(&store)?; put_runtime_role_worker_result(&store, &result)?; assert_eq!(std::fs::read(&store)?, after_first); let mut counterfeit = result.clone(); counterfeit.summary = "Rewritten after persistence".into(); let error = put_runtime_role_worker_result(&store, &counterfeit) .expect_err("a runtime job may publish only one immutable result"); assert!(error.to_string().contains("immutable")); assert_eq!(std::fs::read(&store)?, after_first); Ok(()) } #[test] fn frontier_candidate_and_mind_decision_have_no_public_counterfeit_writers() { let public_surface = include_str!("lib.rs"); assert!(!public_surface.contains("put_repo_frontier_plan_candidate")); assert!(!public_surface.contains("put_repo_frontier_plan_adoption")); } #[test] fn autonomous_direction_promotion_waits_for_thread_without_mutation() -> Result<()> { let root = tempfile::tempdir()?; let store = root.path().join("cold-autonomous-promotion.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "cold-autonomous-runtime".into(), display_name: "Cold autonomous runtime".into(), created_at: "2026-07-19T10:00:00Z".into(), }, )?; let before = std::fs::read(&store)?; assert!( promote_autonomous_direction_options_for_modeling( &store, "GameCult/Epiphany", root.path().to_str().expect("UTF-8 workspace"), "2026-07-19T10:00:01Z", )? .is_empty() ); assert_eq!(std::fs::read(&store)?, before); Ok(()) } #[test] fn autonomous_direction_promotion_waits_for_admitted_model_without_mutation() -> Result<()> { let root = tempfile::tempdir()?; let store = root.path().join("bootstrap-model-without-admission.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "model-wait-runtime".into(), display_name: "Model wait runtime".into(), created_at: "2026-07-19T10:00:00Z".into(), }, )?; let mut cache = runtime_spine_cache(&store)?; cache.put( crate::THREAD_STATE_KEY, &crate::EpiphanyThreadStateEntry::from_state( "thread-without-model", &epiphany_state_model::EpiphanyThreadState::default(), )?, )?; cache.put( crate::MEMORY_GRAPH_KEY, &crate::EpiphanyMemoryGraphEntry::from_snapshot(&crate::EpiphanyMemoryGraphSnapshot { schema_version: Some(crate::MEMORY_GRAPH_SCHEMA_VERSION.into()), graph_id: "bootstrap-model".into(), ..Default::default() })?, )?; let before = std::fs::read(&store)?; assert!( promote_autonomous_direction_options_for_modeling( &store, "GameCult/Epiphany", root.path().to_str().expect("UTF-8 workspace"), "2026-07-19T10:00:01Z", )? .is_empty() ); assert_eq!(std::fs::read(&store)?, before); Ok(()) } #[test] fn autonomous_direction_option_is_atomically_bound_and_selected_for_modeling() -> Result<()> { let root = tempfile::tempdir()?; let (store, modeling_result, review) = proposal_admission_fixture(root.path(), "autonomous-bridge")?; put_runtime_role_worker_result(&store, &modeling_result)?; let admitted = commit_repo_model_admission(&store, &modeling_result.result_id, &review)?; let request = crate::commit_admitted_model_direction_consideration_request( &store, "2026-07-18T01:00:00Z", )? .expect("current admitted model direction request"); assert_eq!(request.model_admission_receipt_id, admitted.receipt_id); let mut launch_cache = runtime_spine_cache(&store)?; launch_cache.pull_all_backing_stores()?; let thread = launch_cache .get::(crate::THREAD_STATE_KEY)? .expect("direction thread state"); let state = thread.state()?; let launch = crate::build_epiphany_admitted_model_direction_consideration_launch_request( &thread.thread_id, Some(state.revision), Some(60), &state, request.request_id.clone(), ) .map_err(|error| anyhow!(error))?; let job_id = "direction-job-autonomous-bridge"; let plan = crate::plan_coordinator_job_launch( &state, &launch, &store, "direction-launcher-autonomous-bridge".into(), job_id.into(), )?; crate::commit_coordinator_job_launch( &store, &thread.thread_id, &state, &launch, &plan, "2026-07-18T01:00:01Z".into(), )?; let direction = crate::AdmittedModelDirectionConsiderationResult { schema_version: crate::ADMITTED_MODEL_DIRECTION_CONSIDERATION_RESULT_SCHEMA_VERSION .into(), result_id: crate::admitted_model_direction_consideration_result_id_for_launch( &request.request_id, job_id, ), request_id: request.request_id.clone(), runtime_id: request.runtime_id.clone(), thread_id: request.thread_id.clone(), model_revision: request.model_revision, model_hash: request.model_hash.clone(), model_admission_receipt_id: request.model_admission_receipt_id.clone(), disposition: crate::AdmittedModelDirectionDisposition::Suggest, summary: "One coherent option fits the admitted map.".into(), option_drafts: vec![crate::ImaginationOptionDraft { title: "Persist autonomous frontier causality".into(), summary: "Carry exact direction and Body provenance into Modeling review.".into(), }], uncertainties: vec!["Modeling must verify source scope.".into()], evidence_refs: vec!["evidence:admitted-map".into()], proposed_at: "2026-07-18T01:00:01Z".into(), contract: crate::ADMITTED_MODEL_DIRECTION_CONSIDERATION_RESULT_CONTRACT.into(), proposal_only: true, terminal: true, }; crate::validate_admitted_model_direction_consideration_result(&request, &direction)?; let body_route = launch_cache .get::(crate::RUNTIME_BODY_STORE_BINDING_KEY)? .expect("autonomous Body route"); let (body_binding, _) = crate::load_repository_body_status(Path::new(&body_route.body_store_path))? .expect("autonomous Body status"); let workspace = body_binding.git_top_level; bind_runtime_repository_domain(&store, "GameCult/Epiphany", "2026-07-18T01:00:01Z")?; let counterfeit_store = root.path().join("counterfeit-direction-companion.cc"); std::fs::copy(&store, &counterfeit_store)?; let mut counterfeit_cache = runtime_spine_cache(&counterfeit_store)?; counterfeit_cache.put(&direction.result_id, &direction)?; let before_counterfeit_promotion = std::fs::read(&counterfeit_store)?; assert!( promote_autonomous_direction_options_for_modeling( &counterfeit_store, "GameCult/Epiphany", &workspace, "2026-07-18T01:00:02Z", ) .is_err() ); assert_eq!( std::fs::read(&counterfeit_store)?, before_counterfeit_promotion ); let worker_result = EpiphanyRuntimeRoleWorkerResult { schema_version: RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.into(), result_id: "worker-result-autonomous-bridge".into(), job_id: job_id.into(), role_id: "imagination".into(), verdict: "proposal-only".into(), summary: direction.summary.clone(), next_safe_move: "Self may route exact options to Modeling review.".into(), checkpoint_summary: None, scratch_summary: None, files_inspected: Vec::new(), frontier_node_ids: Vec::new(), evidence_ids: direction.evidence_refs.clone(), artifact_refs: Vec::new(), open_questions: direction.uncertainties.clone(), evidence_gaps: Vec::new(), risks: Vec::new(), state_patch_msgpack: None, self_patch_msgpack: None, item_error: None, metadata: BTreeMap::new(), repo_model_patch_msgpack: None, verification_request_id: None, frontier_route_id: None, repo_frontier_modeling_request_id: None, proposal_modeling_request_id: None, claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_candidate_msgpack: None, frontier_plan_mind_request_id: None, frontier_plan_mind_decision_msgpack: None, repository_body_observation_basis: None, imagination_consideration_request_id: None, imagination_consideration_candidate_msgpack: None, admitted_model_direction_consideration_request_id: Some(request.request_id.clone()), admitted_model_direction_consideration_result_msgpack: Some(rmp_serde::to_vec_named( &direction, )?), }; put_runtime_role_worker_result(&store, &worker_result)?; let mut companion_cache = runtime_spine_cache(&store)?; companion_cache.pull_all_backing_stores()?; assert_eq!( companion_cache .get::(&direction.result_id)?, Some(direction.clone()) ); let alien_workspace = root.path().join("alien-workspace"); std::fs::create_dir_all(&alien_workspace)?; let before_substitution = std::fs::read(&store)?; assert!( promote_autonomous_direction_options_for_modeling( &store, "GameCult/Epiphany", alien_workspace.to_str().expect("UTF-8 alien workspace"), "2026-07-18T01:00:02Z", ) .is_err() ); assert_eq!(std::fs::read(&store)?, before_substitution); assert!( promote_autonomous_direction_options_for_modeling( &store, "GameCult/Alien", &workspace, "2026-07-18T01:00:02Z", ) .is_err() ); assert_eq!(std::fs::read(&store)?, before_substitution); let selections = promote_autonomous_direction_options_for_modeling( &store, "GameCult/Epiphany", &workspace, "2026-07-18T01:00:02Z", )?; assert_eq!(selections.len(), 1); let selection = &selections[0]; let mut persisted = runtime_spine_cache(&store)?; persisted.pull_all_backing_stores()?; let proposal = persisted .get::(&selection.proposal_id)? .expect("autonomous proposal"); assert!( persisted .get_all::()? .is_empty() ); assert_eq!( proposal.source_kind, crate::RepoFrontierProposalSourceKind::Imagination ); let binding = validate_autonomous_proposal_binding(&persisted, &proposal)?; assert_eq!(binding.direction_result_id, direction.result_id); assert_eq!(binding.model_admission_receipt_id, admitted.receipt_id); let pre_modeling_state = crate::read_coordinator_state(&store)?.expect("autonomous Modeling coordinator state"); let modeling_thread = persisted .get::(crate::THREAD_STATE_KEY)? .expect("autonomous Modeling thread"); let modeling_state = crate::interrupt_coordinator_job( &store, &modeling_thread.thread_id, &pre_modeling_state, EpiphanyJobInterruptRequest { expected_revision: Some(pre_modeling_state.revision), binding_id: "modeling-checkpoint-worker".into(), reason: Some("exercise autonomous direct-Hands refusal".into()), }, )? .epiphany_state; let mut modeling_launch = crate::build_epiphany_role_launch_request( &modeling_thread.thread_id, crate::EpiphanyRoleResultRoleId::Modeling, Some(modeling_state.revision), Some(60), &modeling_state, ) .map_err(|error| anyhow!(error))?; modeling_launch.proposal_modeling_request_id = Some(selection.request_id.clone()); let modeling_job = "autonomous-direct-hands-modeling-job"; let modeling_plan = crate::plan_coordinator_job_launch( &modeling_state, &modeling_launch, &store, "autonomous-direct-hands-launcher".into(), modeling_job.into(), )?; crate::commit_coordinator_job_launch( &store, &modeling_thread.thread_id, &modeling_state, &modeling_launch, &modeling_plan, "2026-07-18T01:00:04Z".into(), )?; let current_model = runtime_current_repo_model(&store)?.expect("autonomous current model"); let hostile_patch = crate::RepoModelPatch { patch_id: "autonomous-direct-hands-patch".into(), base_revision: current_model.model_revision, base_hash: crate::memory_graph_model_hash(¤t_model)?, applied_at: "2026-07-18T01:00:05Z".into(), purpose: crate::RepoModelPatchPurpose::Evolution, operations: vec![crate::RepoModelPatchOperation::UpsertFrontier { item: crate::RepoFrontierItem { id: "autonomous-direct-hands-frontier".into(), migration_body: "Attempt to skip plan adoption.".into(), question: "Can Modeling route an autonomous idea directly to Hands?".into(), gap: "Mind has not adopted a plan.".into(), target_claim_ids: vec!["claim-runtime-model".into()], source_scope: vec!["epiphany-core/src/runtime_spine.rs".into()], recommended_next_organ: "Hands".into(), evidence_refs: vec![proposal.proposal_id.clone()], status: crate::RepoFrontierStatus::Active, ..Default::default() }, }], }; let hostile_patch_bytes = rmp_serde::to_vec_named(&hostile_patch)?; let mut hostile_result = worker_result.clone(); hostile_result.result_id = "autonomous-direct-hands-result".into(); hostile_result.job_id = modeling_job.into(); hostile_result.role_id = "modeling".into(); hostile_result.verdict = "checkpoint-ready".into(); hostile_result.summary = "Attempted direct Hands routing.".into(); hostile_result.next_safe_move = "Mind adoption is required.".into(); hostile_result.files_inspected = vec!["epiphany-core/src/runtime_spine.rs".into()]; hostile_result.frontier_node_ids = vec!["claim-runtime-model".into()]; hostile_result.evidence_ids = vec![proposal.proposal_id.clone()]; hostile_result.repo_model_patch_msgpack = Some(hostile_patch_bytes.clone()); hostile_result.proposal_modeling_request_id = Some(selection.request_id.clone()); hostile_result.repository_body_observation_basis = runtime_worker_launch_body_basis(&store, modeling_job)?; hostile_result.admitted_model_direction_consideration_request_id = None; hostile_result.admitted_model_direction_consideration_result_msgpack = None; put_runtime_role_worker_result(&store, &hostile_result)?; let hostile_review = RepoModelAdmissionReview { schema_version: REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION.into(), review_id: "autonomous-direct-hands-review".into(), result_id: Some(hostile_result.result_id.clone()), job_id: Some(modeling_job.into()), patch_id: hostile_patch.patch_id.clone(), patch_sha256: format!("{:x}", Sha256::digest(&hostile_patch_bytes)), base_revision: hostile_patch.base_revision, base_hash: hostile_patch.base_hash.clone(), decision: MindGatewayDecision::Accept, evidence_ids: hostile_result.evidence_ids.clone(), reviewed_at: "2026-07-18T01:00:06Z".into(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), repository_body_observation_basis: hostile_result .repository_body_observation_basis .clone(), admission_source: Some(crate::RepoModelAdmissionSource::WorkerResult { result_id: hostile_result.result_id.clone(), job_id: modeling_job.into(), }), }; let before_direct_hands_admission = std::fs::read(&store)?; assert!( commit_repo_model_admission(&store, &hostile_result.result_id, &hostile_review,) .is_err() ); assert_eq!(std::fs::read(&store)?, before_direct_hands_admission); assert!( runtime_spine_cache(&store)? .get_all::()? .is_empty() ); assert_eq!( promote_autonomous_direction_options_for_modeling( &store, "GameCult/Epiphany", &workspace, "2026-07-18T01:00:03Z", )?, selections ); let resident_store = root.path().join("autonomous-resident.cc"); let feedback_store = root.path().join("autonomous-feedback.cc"); assert_eq!( crate::ingest_resident_self_domain_pressure( &resident_store, &store, &feedback_store, "proposal-runtime-autonomous-bridge", "GameCult/Epiphany", &workspace, 1_752_796_803_000, )?, 1 ); let grant = crate::resident_self::heartbeat_issue_resident_self_grant( &resident_store, "autonomous-heartbeat", "autonomous-action", 1_752_796_803_001, )? .expect("autonomous Modeling grant"); assert_eq!(grant.pressure_kind, "repo-frontier-proposal-modeling"); assert!(grant.provenance_ref.ends_with(&selection.request_id)); assert_eq!( crate::ingest_resident_self_domain_pressure( &resident_store, &store, &feedback_store, "proposal-runtime-autonomous-bridge", "GameCult/Epiphany", &workspace, 1_752_796_804_000, )?, 0 ); let before = std::fs::read(&store)?; let mut forged = proposal; forged.proposal_id = "forged-imagination-proposal".into(); assert!(put_repo_frontier_work_proposal(&store, &forged).is_err()); assert_eq!(std::fs::read(&store)?, before); Ok(()) } fn proposal_selection_fixture(root: &Path, suffix: &str) -> Result<(PathBuf, String)> { let store = root.join(format!("proposal-selection-{suffix}.cc")); let runtime_id = format!("selection-runtime-{suffix}"); let thread_id = format!("selection-thread-{suffix}"); let proposal_id = format!("selection-proposal-{suffix}"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: runtime_id.clone(), display_name: "Proposal selection fixture".into(), created_at: "2026-07-13T02:00:00Z".into(), }, )?; bind_test_runtime_swarm(&store, "proposal-intake-swarm")?; let mut cache = runtime_spine_cache(&store)?; cache.put( crate::THREAD_STATE_KEY, &crate::EpiphanyThreadStateEntry::from_state( &thread_id, &epiphany_state_model::EpiphanyThreadState::default(), )?, )?; intake_user_repo_frontier_proposal( &store, crate::RepoFrontierUserProposalInput { proposal_id: proposal_id.clone(), source_actor: "fixture-user".into(), source_ref: format!("fixture:{suffix}"), repository: "EpiphanyAgent".into(), workspace: "E:/Projects/EpiphanyAgent".into(), thread_id, runtime_id, title: "Selected contribution".into(), body: "Model this exact proposal".into(), desired_outcome: "One typed frontier".into(), constraints: vec!["No implicit selection".into()], scope_hints: vec!["epiphany-core/src".into()], evidence_refs: vec![format!("fixture:{suffix}")], private_state_included: false, proposed_at: "2026-07-13T02:01:00Z".into(), }, )?; Ok((store, proposal_id)) } fn overwrite_test_entry( store: &Path, key: &str, value: &T, ) -> Result<()> { let mut cache = runtime_spine_cache(store)?; cache.pull_all_backing_stores()?; cache.put(key, value).map(|_| ()) } #[test] fn proposal_intake_selection_and_admission_refuse_hostile_substitution_without_mutation() -> Result<()> { let root = tempdir()?; for (suffix, mutate) in [ ("missing-request", 0u8), ("swapped-request", 1), ("missing-evidence", 2), ("zero-upsert", 3), ("multiple-upsert", 4), ("ordinary-bypass", 5), ("dual-echo", 6), ("unrelated-job", 7), ("unsorted-source-scope", 8), ("proposed-status", 9), ("noncanonical-next-organ", 10), ] { let (store, mut result, mut review) = proposal_admission_fixture(root.path(), suffix)?; match mutate { 0 => result.proposal_modeling_request_id = Some("missing-request".into()), 1 => result.proposal_modeling_request_id = Some("swapped-request".into()), 2 => { result.evidence_ids = vec!["wrong-evidence".into()]; review.evidence_ids = result.evidence_ids.clone(); } 3 => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; patch.operations.clear(); let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_sha256 = format!("{:x}", Sha256::digest(bytes)); } 4 => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; patch.operations.push(patch.operations[0].clone()); let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_sha256 = format!("{:x}", Sha256::digest(bytes)); } 5 => result.proposal_modeling_request_id = None, 6 => result.repo_frontier_modeling_request_id = Some("dual-authority".into()), 7 => result.job_id = "unrelated-modeling-job".into(), 8 => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let crate::RepoModelPatchOperation::UpsertFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.source_scope = vec!["z.rs".into(), "a.rs".into()]; let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_sha256 = format!("{:x}", Sha256::digest(bytes)); } 9 => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let crate::RepoModelPatchOperation::UpsertFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.status = crate::RepoFrontierStatus::Proposed; let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_sha256 = format!("{:x}", Sha256::digest(bytes)); } 10 => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let crate::RepoModelPatchOperation::UpsertFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.recommended_next_organ = "imagination".into(); let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_sha256 = format!("{:x}", Sha256::digest(bytes)); } _ => unreachable!(), } if matches!(mutate, 6 | 7) { let before = std::fs::read(&store)?; assert!(put_runtime_role_worker_result(&store, &result).is_err()); assert_eq!(std::fs::read(&store)?, before); } else { assert_proposal_admission_refused_without_state_mutation(&store, &result, &review)?; } } let (store, result, review) = proposal_admission_fixture(root.path(), "success")?; put_runtime_role_worker_result(&store, &result)?; let receipt = commit_repo_model_admission(&store, &result.result_id, &review)?; assert_eq!( receipt.proposal_modeling_request_id, result.proposal_modeling_request_id.clone().unwrap() ); Ok(()) } #[test] fn proposal_intake_and_selection_bind_authoritative_identity_and_exact_time() -> Result<()> { let root = tempdir()?; let store = root.path().join("proposal-intake.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "intake-runtime".into(), display_name: "Intake".into(), created_at: "2026-07-13T01:00:00Z".into(), }, )?; bind_test_runtime_swarm(&store, "proposal-intake-swarm")?; let mut cache = runtime_spine_cache(&store)?; cache.put( crate::THREAD_STATE_KEY, &crate::EpiphanyThreadStateEntry::from_state( "intake-thread", &epiphany_state_model::EpiphanyThreadState::default(), )?, )?; let input = crate::RepoFrontierUserProposalInput { proposal_id: "intake-proposal".into(), source_actor: "user".into(), source_ref: "message-1".into(), repository: "EpiphanyAgent".into(), workspace: "E:/Projects/EpiphanyAgent".into(), thread_id: "intake-thread".into(), runtime_id: "intake-runtime".into(), title: "Typed artifact".into(), body: " forgedId: evil".into(), desired_outcome: "Contestable contribution".into(), constraints: vec!["bounded".into()], scope_hints: vec!["epiphany-core/src".into()], evidence_refs: vec!["message-1".into()], private_state_included: false, proposed_at: "2026-07-13T01:01:00Z".into(), }; for (suffix, mut hostile) in [ ("runtime", input.clone()), ("thread", input.clone()), ("private", input.clone()), ] { hostile.proposal_id = format!("hostile-{suffix}"); match suffix { "runtime" => hostile.runtime_id = "spoofed".into(), "thread" => hostile.thread_id = "spoofed".into(), "private" => hostile.private_state_included = true, _ => unreachable!(), } let before = std::fs::read(&store)?; assert!(intake_user_repo_frontier_proposal(&store, hostile).is_err()); assert_eq!(std::fs::read(&store)?, before); } intake_user_repo_frontier_proposal(&store, input)?; let selected = select_repo_frontier_work_proposal_for_modeling( &store, "intake-proposal", "2026-07-13T01:02:00Z", )?; assert_eq!( select_repo_frontier_work_proposal_for_modeling( &store, "intake-proposal", "2026-07-13T01:02:00Z" )?, selected ); let legacy = root.path().join("intake.legacy"); ensure_runtime_repo_model( &store, &legacy, &repo_model_bootstrap(), "2026-07-13T01:02:01Z", )?; let before = std::fs::read(&store)?; assert!( select_repo_frontier_work_proposal_for_modeling( &store, "intake-proposal", "2026-07-13T01:03:00Z" ) .is_err() ); assert_eq!(std::fs::read(&store)?, before); Ok(()) } #[test] fn concurrent_exact_proposal_selection_converges_on_one_request() -> Result<()> { let root = tempdir()?; let (store, proposal_id) = proposal_selection_fixture(root.path(), "concurrent")?; let barrier = std::sync::Arc::new(std::sync::Barrier::new(3)); let mut workers = Vec::new(); for _ in 0..2 { let store = store.clone(); let proposal_id = proposal_id.clone(); let barrier = barrier.clone(); workers.push(std::thread::spawn(move || { barrier.wait(); select_repo_frontier_work_proposal_for_modeling( store, &proposal_id, "2026-07-13T02:02:00Z", ) })); } barrier.wait(); let first = workers.remove(0).join().expect("selector thread")?; let second = workers.remove(0).join().expect("selector thread")?; assert_eq!(first, second); let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; assert_eq!( cache .get_all::()? .len(), 1 ); Ok(()) } #[test] fn pending_proposal_modeling_requests_are_a_stable_execution_queue() -> Result<()> { let root = tempdir()?; let (store, proposal_id) = proposal_selection_fixture(root.path(), "queued")?; let first = select_repo_frontier_work_proposal_for_modeling( &store, &proposal_id, "2026-07-13T02:02:00Z", )?; let mut second = first.clone(); second.request_id = "repo-frontier-proposal-modeling-queued-second".into(); second.proposal_id = "queued-second-proposal".into(); second.proposal_payload_sha256 = "22".repeat(32); second.selected_at = "2026-07-13T02:03:00Z".into(); validate_repo_frontier_proposal_modeling_request(&second)?; overwrite_test_entry(&store, &second.request_id, &second)?; assert_eq!( runtime_pending_repo_frontier_proposal_modeling_request(&store)?, Some(first.clone()) ); let first_launch = RepoFrontierProposalModelingLaunchBinding { schema_version: REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_SCHEMA_VERSION.into(), binding_record_id: "queued-first-launch".into(), proposal_modeling_request_id: first.request_id, proposal_id: first.proposal_id, proposal_payload_sha256: first.proposal_payload_sha256, job_id: "queued-first-job".into(), binding_id: "modeling-checkpoint-worker".into(), runtime_id: first.runtime_id, thread_id: first.thread_id, launched_at: "2026-07-13T02:04:00Z".into(), worker_launch_document_sha256: "33".repeat(32), contract: REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_CONTRACT.into(), }; overwrite_test_entry(&store, &first_launch.binding_record_id, &first_launch)?; assert_eq!( runtime_pending_repo_frontier_proposal_modeling_request(&store)?, Some(second) ); Ok(()) } #[test] fn corrupted_proposal_or_selection_is_fail_closed_without_authority_mutation() -> Result<()> { let root = tempdir()?; for corruption in ["schema", "contract", "hash", "privacy"] { let (store, proposal_id) = proposal_selection_fixture(root.path(), corruption)?; let mut proposal = runtime_repo_frontier_work_proposal(&store, &proposal_id)? .expect("fixture proposal"); match corruption { "schema" => proposal.schema_version = "corrupt".into(), "contract" => proposal.contract = "corrupt".into(), "hash" => proposal.payload_sha256 = "00".repeat(32), "privacy" => proposal.private_state_included = true, _ => unreachable!(), } overwrite_test_entry(&store, &proposal_id, &proposal)?; let before = std::fs::read(&store)?; assert!( select_repo_frontier_work_proposal_for_modeling( &store, &proposal_id, "2026-07-13T02:02:00Z" ) .is_err() ); assert_eq!(std::fs::read(&store)?, before); } let (store, proposal_id) = proposal_selection_fixture(root.path(), "request-contract")?; let mut request = select_repo_frontier_work_proposal_for_modeling( &store, &proposal_id, "2026-07-13T02:02:00Z", )?; request.contract = "corrupt".into(); overwrite_test_entry(&store, &request.request_id, &request)?; let before = std::fs::read(&store)?; assert!( select_repo_frontier_work_proposal_for_modeling( &store, &proposal_id, "2026-07-13T02:02:00Z" ) .is_err() ); assert_eq!(std::fs::read(&store)?, before); Ok(()) } #[test] fn proposal_admission_refuses_stale_model_swapped_launch_and_companion_collision() -> Result<()> { let root = tempdir()?; for corruption in ["stale-model", "swapped-launch", "wrong-receipt"] { let (store, mut result, mut review) = proposal_admission_fixture(root.path(), corruption)?; match corruption { "stale-model" => { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; patch.base_revision += 1; patch.base_hash = "00".repeat(32); let bytes = rmp_serde::to_vec_named(&patch)?; review.base_revision = patch.base_revision; review.base_hash = patch.base_hash; review.patch_sha256 = format!("{:x}", Sha256::digest(&bytes)); result.repo_model_patch_msgpack = Some(bytes); } "swapped-launch" => { let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let mut binding = cache .get_all::()? .into_iter() .next() .expect("proposal launch binding"); binding.job_id = "swapped-backend-job".into(); let key = binding.binding_record_id.clone(); overwrite_test_entry(&store, &key, &binding)?; } "wrong-receipt" => { put_runtime_role_worker_result(&store, &result)?; let current = runtime_current_repo_model(&store)?.expect("current model"); let patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let next = crate::derive_repo_model_patch(¤t, &patch)?; let receipt_id = format!("repo-model-admission-{}", review.review_id); let receipt = RepoModelAdmissionReceipt { schema_version: REPO_MODEL_ADMISSION_RECEIPT_SCHEMA_VERSION.into(), receipt_id: receipt_id.clone(), review_id: review.review_id.clone(), result_id: Some(result.result_id.clone()), patch_id: patch.patch_id, patch_sha256: review.patch_sha256.clone(), previous_revision: current.model_revision, previous_hash: crate::memory_graph_model_hash(¤t)?, admitted_revision: next.model_revision, admitted_hash: next.model_hash, admitted_at: review.reviewed_at.clone(), contract: REPO_MODEL_ADMISSION_CONTRACT.into(), purpose: patch.purpose, frontier_route_id: String::new(), verification_request_id: String::new(), soul_verdict_receipt_id: String::new(), frontier_modeling_request_id: String::new(), proposal_modeling_request_id: "wrong-proposal-request".into(), claim_repair_request_id: String::new(), frontier_plan_decision_id: String::new(), repository_body_observation_basis: review .repository_body_observation_basis .clone(), admission_source: review.admission_source.clone(), }; overwrite_test_entry(&store, &review.review_id, &review)?; overwrite_test_entry(&store, &receipt_id, &receipt)?; let before = std::fs::read(&store)?; assert!( commit_repo_model_admission(&store, &result.result_id, &review).is_err() ); assert_eq!(std::fs::read(&store)?, before); continue; } _ => unreachable!(), } assert_proposal_admission_refused_without_state_mutation(&store, &result, &review)?; } Ok(()) } #[test] fn imagination_frontier_selection_is_deterministic_and_dependency_aware() { let mut model = repo_model_bootstrap(); let item = |id: &str, dependencies: Vec<&str>| crate::RepoFrontierItem { id: id.into(), migration_body: "body".into(), question: "question".into(), gap: "gap".into(), recommended_next_organ: "Imagination".into(), source_scope: vec!["epiphany-core/src".into()], dependency_item_ids: dependencies.into_iter().map(str::to_string).collect(), status: crate::RepoFrontierStatus::Active, ..Default::default() }; model.frontier = vec![ item("z-ready", vec![]), item("a-blocked", vec!["dependency"]), crate::RepoFrontierItem { id: "dependency".into(), status: crate::RepoFrontierStatus::Blocked, ..Default::default() }, item("b-ready", vec![]), ]; assert_eq!( actionable_imagination_frontier_item(&model, &[]) .unwrap() .id, "b-ready" ); model.frontier[2].status = crate::RepoFrontierStatus::Resolved; assert_eq!( actionable_imagination_frontier_item(&model, &[]) .unwrap() .id, "a-blocked" ); } pub(crate) fn claim_challenge_fixture( root: &Path, suffix: &str, next_organ: &str, ) -> Result<(PathBuf, RepoModelClaimChallenge)> { let (store, result, review) = proposal_admission_fixture(root, suffix)?; let mut result = result; if next_organ != "Hands" { let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let crate::RepoModelPatchOperation::UpsertFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.recommended_next_organ = next_organ.into(); let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); let mut amended = review; amended.patch_sha256 = format!("{:x}", Sha256::digest(&bytes)); put_runtime_role_worker_result(&store, &result)?; commit_repo_model_admission(&store, &result.result_id, &amended)?; } else { put_runtime_role_worker_result(&store, &result)?; commit_repo_model_admission(&store, &result.result_id, &review)?; } let model = runtime_current_repo_model(&store)?.unwrap(); let model_hash = crate::memory_graph_model_hash(&model)?; let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let admission = cache .get_all::()? .into_iter() .find(|receipt| { receipt.admitted_revision == model.model_revision && receipt.admitted_hash == model_hash }) .unwrap(); let packet = EyesEvidencePacket { schema_version: EYES_EVIDENCE_PACKET_SCHEMA_VERSION.into(), packet_id: format!("eyes-packet-{suffix}"), source_result_id: format!("eyes-result-{suffix}"), source_job_id: format!("eyes-job-{suffix}"), source_role_id: "research".into(), evidence_ids: vec![format!("evidence-{suffix}")], observation_ids: vec![format!("observation-{suffix}")], source_refs: vec!["epiphany-core/src/runtime_spine.rs:1".into()], summary: "The exact claim is challenged by inspected source.".into(), uncertainty: "Bounded to the cited source.".into(), emitted_at: "2026-07-13T04:01:00Z".into(), contract: "Eyes packet emitted from a reviewed Research lane finding; it makes the source-gathering evidence claim citable before Mind admission.".into(), }; put_eyes_evidence_packet(&store, &packet)?; let claim = model .nodes .iter() .find(|node| node.id == "claim-runtime-model") .unwrap(); let challenge = RepoModelClaimChallenge { schema_version: REPO_MODEL_CLAIM_CHALLENGE_SCHEMA_VERSION.into(), challenge_id: format!("claim-challenge-{suffix}"), eyes_evidence_packet_id: packet.packet_id.clone(), eyes_evidence_packet_sha256: format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(&packet)?) ), source_result_id: packet.source_result_id, source_job_id: packet.source_job_id, model_revision: model.model_revision, model_hash, admission_receipt_id: admission.receipt_id, target_claim_id: claim.id.clone(), target_claim_sha256: format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(claim)?)), disposition: crate::RepoModelClaimChallengeDisposition::Contradicted, finding: "The exact admitted claim is contradicted.".into(), uncertainty: packet.uncertainty, source_refs: packet.source_refs, evidence_ids: packet.evidence_ids, challenged_at: "2026-07-13T04:01:01Z".into(), contract: REPO_MODEL_CLAIM_CHALLENGE_CONTRACT.into(), }; Ok((store, challenge)) } #[test] fn claim_challenge_is_exact_immutable_and_rejects_substitution() -> Result<()> { let root = tempdir()?; let (store, challenge) = claim_challenge_fixture(root.path(), "exact", "Hands")?; commit_repo_model_claim_challenge(&store, &challenge)?; commit_repo_model_claim_challenge(&store, &challenge)?; let mut collision = challenge.clone(); collision.finding = "substituted finding".into(); assert!(commit_repo_model_claim_challenge(&store, &collision).is_err()); for (suffix, mutate) in [ "packet-id", "packet-hash", "provenance", "admission", "claim", "claim-hash", "revision", ] .into_iter() .enumerate() { let (hostile_store, mut hostile) = claim_challenge_fixture(root.path(), &format!("hostile-{suffix}"), "Hands")?; match mutate { "packet-id" => hostile.eyes_evidence_packet_id = "swapped-packet".into(), "packet-hash" => hostile.eyes_evidence_packet_sha256 = "00".repeat(32), "provenance" => hostile.source_job_id = "swapped-job".into(), "admission" => hostile.admission_receipt_id = "swapped-admission".into(), "claim" => hostile.target_claim_id = "swapped-claim".into(), "claim-hash" => hostile.target_claim_sha256 = "11".repeat(32), "revision" => hostile.model_revision += 1, _ => unreachable!(), } let before = std::fs::read(&hostile_store)?; assert!(commit_repo_model_claim_challenge(&hostile_store, &hostile).is_err()); assert_eq!(std::fs::read(&hostile_store)?, before); } Ok(()) } #[test] fn current_claim_challenge_withholds_planning_and_hands_but_not_unrelated_frontier() -> Result<()> { let root = tempdir()?; let (hands_store, hands_challenge) = claim_challenge_fixture(root.path(), "hands-gate", "Hands")?; commit_repo_model_claim_challenge(&hands_store, &hands_challenge)?; assert!(!runtime_has_actionable_hands_frontier(&hands_store)?); assert!( select_and_commit_repo_frontier_route(&hands_store, "2026-07-13T04:02:00Z").is_err() ); let (eyes_store, eyes_challenge) = claim_challenge_fixture(root.path(), "eyes-regather", "Eyes")?; commit_repo_model_claim_challenge(&eyes_store, &eyes_challenge)?; assert!(runtime_has_actionable_eyes_frontier(&eyes_store)?); let (planning_store, planning_challenge) = claim_challenge_fixture(root.path(), "planning-gate", "Imagination")?; commit_repo_model_claim_challenge(&planning_store, &planning_challenge)?; let eligibility = runtime_repo_frontier_planning_eligibility(&planning_store)?; assert_eq!(eligibility.current_admission_count, 1); assert_eq!(eligibility.candidates.len(), 1); assert!(!eligibility.candidates[0].eligible); assert!(eligibility.candidates[0].status_valid); assert!(eligibility.candidates[0].recommended_next_organ_valid); assert!(eligibility.candidates[0].source_scope_valid); assert_eq!( eligibility.candidates[0].challenged_target_claim_ids, vec![planning_challenge.target_claim_id.clone()] ); assert!( eligibility.candidates[0] .unresolved_dependency_item_ids .is_empty() ); assert!( select_and_commit_repo_frontier_planning_request( &planning_store, "2026-07-13T04:02:00Z" ) .is_err() ); let mut unrelated = repo_model_bootstrap(); unrelated.frontier = vec![crate::RepoFrontierItem { id: "unrelated".into(), target_claim_ids: vec!["another-claim".into()], source_scope: vec!["epiphany-core/src".into()], recommended_next_organ: "Hands".into(), status: crate::RepoFrontierStatus::Active, ..Default::default() }]; assert_eq!( actionable_hands_frontier_item(&unrelated, &[hands_challenge]) .unwrap() .id, "unrelated" ); Ok(()) } #[test] fn immediate_claim_repair_request_deduplicates_shared_admission_companion() -> Result<()> { let root = tempdir()?; let (store, challenge) = claim_challenge_fixture(root.path(), "repair-immediate", "Hands")?; commit_repo_model_claim_challenge(&store, &challenge)?; let request = commit_repo_model_claim_repair_request( &store, &challenge.challenge_id, "2026-07-13T04:02:00Z", )?; assert_eq!( request.original_admission_receipt_id, request.current_admission_receipt_id ); let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; assert_eq!( cache.get_all::()?, vec![request] ); Ok(()) } #[test] fn claim_challenge_survives_unrelated_admission_and_emits_inert_exact_request() -> Result<()> { let root = tempdir()?; let (store, challenge) = claim_challenge_fixture(root.path(), "repair", "Hands")?; commit_repo_model_claim_challenge(&store, &challenge)?; // An unrelated proposal admission advances the model without changing the // challenged claim. That must not launder the Eyes pressure away. let before_unrelated = runtime_current_repo_model(&store)?.unwrap(); let (unrelated_result, unrelated_review) = repo_model_result_and_review( &store, "unrelated-after-challenge", "unrelated-after-challenge-job", &before_unrelated, "unrelated-after-challenge-review", )?; put_runtime_role_worker_result(&store, &unrelated_result)?; commit_repo_model_admission(&store, &unrelated_result.result_id, &unrelated_review)?; let after_unrelated = runtime_current_repo_model(&store)?.unwrap(); let after_unrelated_hash = crate::memory_graph_model_hash(&after_unrelated)?; let challenged_claim_after_unrelated = after_unrelated .nodes .iter() .find(|node| node.id == challenge.target_claim_id) .unwrap(); assert_eq!( format!( "{:x}", Sha256::digest(rmp_serde::to_vec_named(challenged_claim_after_unrelated)?) ), challenge.target_claim_sha256 ); let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; assert_eq!( current_repo_model_claim_challenges(&cache, &after_unrelated, &after_unrelated_hash)? .len(), 1 ); let request = commit_repo_model_claim_repair_request( &store, &challenge.challenge_id, "2026-07-13T04:03:00Z", )?; assert_eq!(request.target_claim_id, challenge.target_claim_id); assert_eq!( commit_repo_model_claim_repair_request( &store, &challenge.challenge_id, "2026-07-13T04:03:00Z" )?, request ); assert_eq!( request.eyes_evidence_packet_id, challenge.eyes_evidence_packet_id ); assert_eq!( request.original_admission_receipt_id, challenge.admission_receipt_id ); assert_ne!(request.current_admission_receipt_id, ""); assert_eq!(request.runtime_id, "proposal-runtime-repair"); assert!( commit_repo_model_claim_repair_request( &store, &challenge.challenge_id, "2026-07-13T04:04:00Z" ) .is_err() ); Ok(()) } fn admit_route_and_authorize_hands( store: &Path, intent: &HandsActionIntent, review: &HandsActionReview, suffix: &str, ) -> Result<(RepoFrontierRoute, RepoFrontierHandsAuthority)> { if runtime_swarm_binding(store)?.is_none() { bind_test_runtime_swarm(store, &format!("route-swarm-{suffix}"))?; } let bootstrap = repo_model_bootstrap(); let legacy = store.with_extension(format!("{suffix}.legacy.msgpack")); let (current, _) = ensure_runtime_repo_model(store, &legacy, &bootstrap, "2026-07-13T04:00:00Z")?; let (mut result, mut admission_review) = repo_model_result_and_review( store, &format!("route-result-{suffix}"), &format!("route-job-{suffix}"), ¤t, &format!("route-review-{suffix}"), )?; let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let crate::RepoModelPatchOperation::UpsertFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.source_scope = intent.requested_paths.clone(); let patch_bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(patch_bytes.clone()); admission_review.patch_sha256 = format!("{:x}", Sha256::digest(&patch_bytes)); put_runtime_role_worker_result(store, &result)?; commit_repo_model_admission(store, &result.result_id, &admission_review)?; let route = select_and_commit_repo_frontier_route(store, "2026-07-13T04:00:02Z")?; let authority = RepoFrontierHandsAuthority { schema_version: REPO_FRONTIER_HANDS_AUTHORITY_SCHEMA_VERSION.to_string(), authority_id: format!("route-authority-{suffix}"), route_id: route.route_id.clone(), model_revision: route.model_revision, model_hash: route.model_hash.clone(), frontier_item_id: route.frontier_item_id.clone(), frontier_item_hash: route.frontier_item_hash.clone(), hands_intent_id: intent.intent_id.clone(), hands_review_id: review.review_id.clone(), substrate_grant_receipt_id: intent.substrate_gate_grant_receipt_id.clone(), requested_paths: intent.requested_paths.clone(), granted_at: "2026-07-13T04:00:03Z".to_string(), contract: REPO_FRONTIER_HANDS_AUTHORITY_CONTRACT.to_string(), }; put_repo_frontier_hands_authority(store, &authority)?; Ok((route, authority)) } #[test] fn hands_relinquishment_atomically_retires_route_authority_without_consequences() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "relinquishment-runtime".to_string(), display_name: "Relinquishment".to_string(), created_at: "2026-08-08T12:00:00Z".to_string(), }, )?; let paths = vec!["epiphany-core/src/runtime_spine.rs".to_string()]; let grant = crate::substrate_gate_coordinator_implementation_grant( "relinquishment-grant".to_string(), "relinquishment-job".to_string(), paths.clone(), "2026-08-08T12:00:01Z".to_string(), ); put_substrate_gate_repo_access_grant_receipt(&store, &grant)?; let intent = HandsActionIntent { schema_version: HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: "relinquishment-intent".to_string(), runtime_job_id: grant.runtime_job_id.clone(), binding_id: grant.binding_id.clone(), role: grant.role.clone(), authority_scope: grant.authority_scope.clone(), requested_action: "patch".to_string(), requested_paths: paths, substrate_gate_grant_receipt_id: grant.receipt_id.clone(), requested_at: "2026-08-08T12:00:02Z".to_string(), contract: "test".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; put_hands_action_intent(&store, &intent)?; let review = crate::hands_action_review_for_intent( "relinquishment-review".to_string(), &intent, "approved".to_string(), vec!["patch".to_string()], vec!["bounded route".to_string()], "2026-08-08T12:00:03Z".to_string(), ); put_hands_action_review(&store, &review)?; let (route, authority) = admit_route_and_authorize_hands(&store, &intent, &review, "relinquishment")?; let before = runtime_current_repo_model(&store)?.expect("current model"); assert!( relinquish_repo_frontier_hands_route( &store, &intent.intent_id, &review.review_id, "hands-refusal-not-a-gap", vec!["epiphany-core/src/runtime_spine.rs".to_string()], "This path was already authorized.".to_string(), "2026-08-08T12:00:04Z".to_string(), ) .is_err() ); assert_eq!(runtime_current_repo_model(&store)?.unwrap(), before); let receipt = relinquish_repo_frontier_hands_route( &store, &intent.intent_id, &review.review_id, "hands-refusal-relinquishment", vec!["epiphany-state-model/src/lib.rs".to_string()], "The adopted path ceiling cannot express the required authority transfer.".to_string(), "2026-08-08T12:00:04Z".to_string(), )?; let after = runtime_current_repo_model(&store)?.expect("current model"); assert_eq!(receipt.route_id, route.route_id); assert_eq!(receipt.previous_model_revision, before.model_revision); assert_eq!(receipt.admitted_model_revision, before.model_revision + 1); assert_eq!(after.model_revision, receipt.admitted_model_revision); assert_eq!( after .frontier .iter() .find(|item| item.id == route.frontier_item_id) .expect("retained frontier") .status, crate::RepoFrontierStatus::Retired ); assert!(!runtime_has_actionable_hands_frontier(&store)?); assert!(put_repo_frontier_hands_authority(&store, &authority).is_err()); assert_eq!( relinquish_repo_frontier_hands_route( &store, &intent.intent_id, &review.review_id, "hands-refusal-relinquishment", vec!["epiphany-state-model/src/lib.rs".to_string()], "The adopted path ceiling cannot express the required authority transfer." .to_string(), "2026-08-08T12:00:04Z".to_string(), )?, receipt ); assert!( relinquish_repo_frontier_hands_route( &store, &intent.intent_id, &review.review_id, "hands-refusal-relinquishment", vec!["epiphany-state-model/src/lib.rs".to_string()], "collision".to_string(), "2026-08-08T12:00:04Z".to_string(), ) .is_err() ); Ok(()) } struct FrontierVerdictFixture { store: std::path::PathBuf, route: RepoFrontierRoute, request: RepoFrontierVerificationRequest, verdict: SoulVerdictReceipt, modeling_request: RepoFrontierModelingRequest, current: crate::EpiphanyMemoryGraphSnapshot, } fn frontier_verdict_fixture( root: &Path, suffix: &str, verdict_text: &str, ) -> Result { let store = root.join(format!("runtime-{suffix}.cc")); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: format!("verdict-{suffix}"), display_name: "Verdict incorporation".to_string(), created_at: "2026-07-13T06:00:00Z".to_string(), }, )?; let paths = vec!["epiphany-core/src/runtime_spine.rs".to_string()]; let grant = crate::substrate_gate_coordinator_implementation_grant( format!("grant-{suffix}"), format!("hands-job-{suffix}"), paths.clone(), "2026-07-13T06:00:01Z".to_string(), ); put_substrate_gate_repo_access_grant_receipt(&store, &grant)?; let intent = HandsActionIntent { schema_version: crate::HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: format!("intent-{suffix}"), runtime_job_id: format!("hands-job-{suffix}"), binding_id: "implementation-worker".to_string(), role: "epiphany-hands".to_string(), authority_scope: "epiphany.role.implementation".to_string(), requested_action: "patch".to_string(), requested_paths: paths.clone(), substrate_gate_grant_receipt_id: grant.receipt_id.clone(), requested_at: "2026-07-13T06:00:02Z".to_string(), contract: "test Hands intent".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; put_hands_action_intent(&store, &intent)?; let review = crate::hands_action_review_for_intent( format!("hands-review-{suffix}"), &intent, "approved".to_string(), vec![ "patch".to_string(), "command".to_string(), "commit".to_string(), ], vec!["exact route scope".to_string()], "2026-07-13T06:00:03Z".to_string(), ); put_hands_action_review(&store, &review)?; let (route, _) = admit_route_and_authorize_hands(&store, &intent, &review, suffix)?; let patch_receipt = crate::hands_patch_receipt_for_review( format!("hands-patch-{suffix}"), &intent, &review, paths.clone(), "patch".to_string(), "2026-07-13T06:00:04Z".to_string(), ); put_hands_patch_receipt(&store, &patch_receipt)?; let command_receipt = crate::hands_command_receipt_for_review( format!("hands-command-{suffix}"), &intent, &review, "cargo test".to_string(), "0".to_string(), "stdout".to_string(), "stderr".to_string(), "green".to_string(), "2026-07-13T06:00:05Z".to_string(), ); put_hands_command_receipt(&store, &command_receipt)?; let commit_receipt = crate::hands_commit_receipt_for_review( format!("hands-commit-{suffix}"), &intent, &review, "abc123".to_string(), "main".to_string(), paths, "commit".to_string(), "2026-07-13T06:00:06Z".to_string(), ); put_hands_commit_receipt(&store, &commit_receipt)?; let chain = runtime_latest_hands_receipt_chain_after(&store, "2026-07-13T05:59:59Z")? .expect("complete Hands chain"); let request = commit_repo_frontier_verification_request_for_chain( &store, &chain, "2026-07-13T06:00:07Z", )?; let verification_result = EpiphanyRuntimeRoleWorkerResult { schema_version: RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.to_string(), repository_body_observation_basis: None, result_id: format!("verification-result-{suffix}"), job_id: format!("verification-job-{suffix}"), role_id: "verification".to_string(), verdict: verdict_text.to_string(), summary: format!("Soul says {verdict_text}."), next_safe_move: "Return verdict to Modeling.".to_string(), checkpoint_summary: None, scratch_summary: None, files_inspected: Vec::new(), frontier_node_ids: Vec::new(), evidence_ids: vec![format!("verification-evidence-{suffix}")], artifact_refs: Vec::new(), open_questions: Vec::new(), evidence_gaps: Vec::new(), risks: Vec::new(), state_patch_msgpack: None, self_patch_msgpack: None, item_error: None, metadata: BTreeMap::new(), repo_model_patch_msgpack: None, verification_request_id: Some(request.request_id.clone()), frontier_route_id: Some(route.route_id.clone()), repo_frontier_modeling_request_id: None, proposal_modeling_request_id: None, claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_candidate_msgpack: None, frontier_plan_mind_request_id: None, frontier_plan_mind_decision_msgpack: None, imagination_consideration_request_id: None, imagination_consideration_candidate_msgpack: None, admitted_model_direction_consideration_request_id: None, admitted_model_direction_consideration_result_msgpack: None, }; put_test_non_modeling_worker_launch(&store, &verification_result.job_id, "verification")?; put_runtime_role_worker_result(&store, &verification_result)?; let verdict = SoulVerdictReceipt { schema_version: SOUL_VERDICT_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: format!("soul-verdict-{suffix}"), source_result_id: verification_result.result_id.clone(), source_job_id: verification_result.job_id.clone(), verdict: verdict_text.to_string(), summary: verification_result.summary.clone(), evidence_ids: verification_result.evidence_ids.clone(), risks: verification_result.risks.clone(), emitted_at: "2026-07-13T06:00:08Z".to_string(), contract: "accepted exact Verification finding".to_string(), verification_request_id: request.request_id.clone(), frontier_route_id: route.route_id.clone(), }; put_soul_verdict_receipt(&store, &verdict)?; let acceptance = epiphany_state_model::EpiphanyAcceptanceReceipt { id: format!("verification-acceptance-{suffix}"), result_id: verification_result.result_id.clone(), job_id: verification_result.job_id.clone(), binding_id: "verification-worker".to_string(), surface: "roleAccept".to_string(), role_id: "verification".to_string(), status: "accepted".to_string(), accepted_at: "2026-07-13T06:00:08Z".to_string(), ..Default::default() }; let accepted_state = epiphany_state_model::EpiphanyThreadState { revision: 1, acceptance_receipts: vec![acceptance.clone()], ..Default::default() }; let mut state_cache = runtime_spine_cache(&store)?; state_cache.put( crate::THREAD_STATE_KEY, &crate::EpiphanyThreadStateEntry::from_state("fixture-thread", &accepted_state)?, )?; let modeling_request = commit_repo_frontier_modeling_request(&store, &acceptance)?; let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let current = cache .get::(crate::MEMORY_GRAPH_KEY)? .expect("current model") .snapshot()?; Ok(FrontierVerdictFixture { store, route, request, verdict, modeling_request, current, }) } #[test] fn hands_relinquishment_refuses_to_erase_existing_consequences() -> Result<()> { let temp = tempdir()?; let fixture = frontier_verdict_fixture(temp.path(), "relinquish-after-work", "pass")?; let mut cache = runtime_spine_cache(&fixture.store)?; cache.pull_all_backing_stores()?; let authority = cache .get_all::()? .into_iter() .find(|authority| authority.route_id == fixture.route.route_id) .expect("route authority"); let before = fs::read(&fixture.store)?; assert!( relinquish_repo_frontier_hands_route( &fixture.store, &authority.hands_intent_id, &authority.hands_review_id, "hands-refusal-after-consequence", vec!["epiphany-state-model/src/lib.rs".to_string()], "Too late to claim no consequence.".to_string(), "2026-08-08T12:00:09Z".to_string(), ) .is_err() ); assert_eq!(fs::read(&fixture.store)?, before); Ok(()) } fn incorporation_result_and_review( fixture: &FrontierVerdictFixture, suffix: &str, ) -> Result<(EpiphanyRuntimeRoleWorkerResult, RepoModelAdmissionReview)> { bind_test_repository_body(&fixture.store, &format!("verdict-workspace-{suffix}"))?; let state = crate::read_coordinator_state(&fixture.store)? .ok_or_else(|| anyhow!("verdict fixture has no coordinator state"))?; let thread_id = { let mut cache = runtime_spine_cache(&fixture.store)?; cache.pull_all_backing_stores()?; cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("verdict fixture has no thread state entry"))? .thread_id }; let launch = crate::build_epiphany_role_launch_request( &thread_id, crate::EpiphanyRoleResultRoleId::Modeling, Some(state.revision), Some(60), &state, ) .map_err(|error| anyhow!(error))?; let job_id = format!("incorporation-job-{suffix}"); let plan = crate::plan_coordinator_job_launch( &state, &launch, &fixture.store, format!("incorporation-launcher-{suffix}"), job_id.clone(), )?; crate::commit_coordinator_job_launch( &fixture.store, &thread_id, &state, &launch, &plan, "2026-07-13T06:00:09Z".into(), )?; let mut item = fixture .current .frontier .iter() .find(|item| item.id == fixture.route.frontier_item_id) .expect("routed item") .clone(); if fixture.verdict.verdict == "pass" { item.status = crate::RepoFrontierStatus::Resolved; } else { item.status = crate::RepoFrontierStatus::Blocked; item.gap = format!( "Soul verdict {} requires another cut.", fixture.verdict.verdict ); } item.updated_at = Some("2026-07-13T06:00:09Z".to_string()); item.evidence_refs.push(fixture.request.request_id.clone()); item.evidence_refs.push(fixture.verdict.receipt_id.clone()); item.evidence_refs.sort(); item.evidence_refs.dedup(); let patch = crate::RepoModelPatch { patch_id: format!("incorporation-patch-{suffix}"), base_revision: fixture.current.model_revision, base_hash: crate::memory_graph_model_hash(&fixture.current)?, applied_at: "2026-07-13T06:00:09Z".to_string(), purpose: crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { route_id: fixture.route.route_id.clone(), soul_verdict_receipt_id: fixture.verdict.receipt_id.clone(), }, operations: vec![crate::RepoModelPatchOperation::ReviseFrontier { item }], }; let bytes = rmp_serde::to_vec_named(&patch)?; let result = EpiphanyRuntimeRoleWorkerResult { schema_version: RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.to_string(), repository_body_observation_basis: runtime_worker_launch_body_basis( &fixture.store, &job_id, )?, result_id: format!("incorporation-result-{suffix}"), job_id, role_id: "modeling".to_string(), verdict: "checkpoint-ready".to_string(), summary: "Incorporate exact Soul verdict.".to_string(), next_safe_move: "Mind admission.".to_string(), checkpoint_summary: None, scratch_summary: None, files_inspected: Vec::new(), frontier_node_ids: Vec::new(), evidence_ids: vec![fixture.verdict.receipt_id.clone()], artifact_refs: Vec::new(), open_questions: Vec::new(), evidence_gaps: Vec::new(), risks: Vec::new(), state_patch_msgpack: None, self_patch_msgpack: None, item_error: None, metadata: BTreeMap::new(), repo_model_patch_msgpack: Some(bytes.clone()), verification_request_id: None, frontier_route_id: None, repo_frontier_modeling_request_id: Some(fixture.modeling_request.request_id.clone()), proposal_modeling_request_id: None, claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_candidate_msgpack: None, frontier_plan_mind_request_id: None, frontier_plan_mind_decision_msgpack: None, imagination_consideration_request_id: None, imagination_consideration_candidate_msgpack: None, admitted_model_direction_consideration_request_id: None, admitted_model_direction_consideration_result_msgpack: None, }; let review = RepoModelAdmissionReview { schema_version: REPO_MODEL_ADMISSION_REVIEW_SCHEMA_VERSION.to_string(), review_id: format!("incorporation-review-{suffix}"), result_id: Some(result.result_id.clone()), job_id: Some(result.job_id.clone()), patch_id: patch.patch_id, patch_sha256: format!("{:x}", Sha256::digest(&bytes)), base_revision: patch.base_revision, base_hash: patch.base_hash, decision: MindGatewayDecision::Accept, evidence_ids: result.evidence_ids.clone(), reviewed_at: "2026-07-13T06:00:10Z".to_string(), contract: REPO_MODEL_ADMISSION_CONTRACT.to_string(), repository_body_observation_basis: result.repository_body_observation_basis.clone(), admission_source: Some(crate::RepoModelAdmissionSource::WorkerResult { result_id: result.result_id.clone(), job_id: result.job_id.clone(), }), }; Ok((result, review)) } #[test] fn repo_model_migration_and_specialized_admission_are_atomic_and_bound() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "repo-model-test".to_string(), display_name: "Repo Model Test".to_string(), created_at: "2026-07-13T00:00:00Z".to_string(), }, )?; bind_test_runtime_swarm(&store, "repo-model-test-swarm")?; let bootstrap = repo_model_bootstrap(); let (current, migration) = ensure_runtime_repo_model( &store, temp.path().join("missing-legacy.cc"), &bootstrap, "2026-07-13T03:00:00Z", )?; assert_eq!(migration.imported_revision, 0); let mut projection_cache = runtime_spine_cache(&store)?; projection_cache.pull_all_backing_stores()?; assert_eq!( projection_cache .get_all::()? .len(), 1 ); let (result, review) = repo_model_result_and_review( &store, "model-result-1", "model-job-1", ¤t, "review-1", )?; put_runtime_role_worker_result(&store, &result)?; let receipt = commit_repo_model_admission(&store, &result.result_id, &review)?; assert_eq!(receipt.admitted_revision, 1); let mut projection_cache = runtime_spine_cache(&store)?; projection_cache.pull_all_backing_stores()?; assert_eq!( projection_cache .get_all::()? .len(), 2 ); assert_eq!( commit_repo_model_admission(&store, &result.result_id, &review)?, receipt ); let (still_admitted, same_migration) = ensure_runtime_repo_model( &store, temp.path().join("missing-legacy.cc"), &repo_model_bootstrap(), "2026-07-13T05:00:00Z", )?; assert_eq!(still_admitted.model_revision, 1); assert_eq!(same_migration, migration); let bytes_before = fs::read(&store)?; let mut swapped_result = review.clone(); swapped_result.result_id = Some("other-result".to_string()); assert!(commit_repo_model_admission(&store, &result.result_id, &swapped_result).is_err()); let mut swapped_patch = review.clone(); swapped_patch.review_id = "review-swapped-patch".to_string(); swapped_patch.patch_sha256 = "0".repeat(64); assert!(commit_repo_model_admission(&store, &result.result_id, &swapped_patch).is_err()); assert_eq!(fs::read(&store)?, bytes_before); let mut admitted_cache = runtime_spine_cache(&store)?; admitted_cache.pull_all_backing_stores()?; let admitted = admitted_cache .get::(crate::MEMORY_GRAPH_KEY)? .expect("admitted model") .snapshot()?; let (stale_result, stale_review) = repo_model_result_and_review( &store, "model-result-stale", "model-job-stale", ¤t, "review-stale", )?; put_runtime_role_worker_result(&store, &stale_result)?; let stale_bytes = fs::read(&store)?; assert!( commit_repo_model_admission(&store, &stale_result.result_id, &stale_review).is_err() ); assert_eq!(fs::read(&store)?, stale_bytes); assert_eq!(admitted.model_revision, 1); let (collision_result, collision_review) = repo_model_result_and_review( &store, "model-result-collision", "model-job-collision", &admitted, "review-collision", )?; put_runtime_role_worker_result(&store, &collision_result)?; let mut counterfeit = collision_review.clone(); counterfeit.decision = MindGatewayDecision::Hold; let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; cache.put(&counterfeit.review_id, &counterfeit)?; let collision_bytes = fs::read(&store)?; assert!( commit_repo_model_admission(&store, &collision_result.result_id, &collision_review) .is_err() ); assert_eq!(fs::read(&store)?, collision_bytes); Ok(()) } #[test] fn repo_model_bootstrap_requires_exact_immutable_runtime_swarm_binding() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime-binding.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "runtime-binding-test".into(), display_name: "Runtime binding test".into(), created_at: "2026-07-13T00:00:00Z".into(), }, )?; let before = fs::read(&store)?; assert!( ensure_runtime_repo_model( &store, temp.path().join("absent.cc"), &repo_model_bootstrap(), "2026-07-13T00:00:02Z" ) .is_err() ); assert_eq!(fs::read(&store)?, before); let agent_store = temp.path().join("agents.cc"); crate::ensure_agent_memory_swarm_identity(&agent_store, "swarm-binding-test")?; let binding = bind_runtime_to_agent_memory_swarm(&store, &agent_store, "2026-07-13T00:00:01Z")?; assert_eq!( bind_runtime_to_agent_memory_swarm(&store, &agent_store, "2026-07-13T00:00:01Z")?, binding ); let other_agents = temp.path().join("other-agents.cc"); crate::ensure_agent_memory_swarm_identity(&other_agents, "other-swarm")?; assert!( bind_runtime_to_agent_memory_swarm(&store, &other_agents, "2026-07-13T00:00:01Z") .is_err() ); Ok(()) } #[test] fn evolution_cannot_bypass_routes_or_own_frontier_verdict_lifecycle() -> Result<()> { let routed_temp = tempdir()?; let routed = frontier_verdict_fixture(routed_temp.path(), "evolution-route", "pass")?; let (routed_result, routed_review) = repo_model_result_and_review( &routed.store, "evolution-after-route", "evolution-after-route-job", &routed.current, "evolution-after-route-review", )?; put_runtime_role_worker_result(&routed.store, &routed_result)?; let before = fs::read(&routed.store)?; assert!( commit_repo_model_admission(&routed.store, &routed_result.result_id, &routed_review) .is_err() ); assert_eq!(fs::read(&routed.store)?, before); let temp = tempdir()?; let store = temp.path().join("evolution-lifecycle.cc"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "evolution-lifecycle".to_string(), display_name: "Evolution lifecycle".to_string(), created_at: "2026-07-13T08:00:00Z".to_string(), }, )?; bind_test_runtime_swarm(&store, "evolution-lifecycle-swarm")?; let (base, _) = ensure_runtime_repo_model( &store, temp.path().join("legacy.cc"), &repo_model_bootstrap(), "2026-07-13T08:00:00Z", )?; let (seed_result, seed_review) = repo_model_result_and_review( &store, "evolution-seed", "evolution-seed-job", &base, "evolution-seed-review", )?; put_runtime_role_worker_result(&store, &seed_result)?; commit_repo_model_admission(&store, &seed_result.result_id, &seed_review)?; let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let current = cache .get::(crate::MEMORY_GRAPH_KEY)? .unwrap() .snapshot()?; for (suffix, operation) in [ ("resolved", { let mut item = current.frontier[0].clone(); item.status = crate::RepoFrontierStatus::Resolved; crate::RepoModelPatchOperation::ReviseFrontier { item } }), ( "retire", crate::RepoModelPatchOperation::RetireFrontier { item_id: current.frontier[0].id.clone(), retired_at: None, superseded_by: None, }, ), ] { let (mut result, mut review) = repo_model_result_and_review( &store, &format!("evolution-{suffix}"), &format!("evolution-{suffix}-job"), ¤t, &format!("evolution-{suffix}-review"), )?; let mut patch = result.repo_model_patch()?.unwrap(); patch.operations = vec![operation]; let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); review.patch_sha256 = format!("{:x}", Sha256::digest(&bytes)); put_runtime_role_worker_result(&store, &result)?; let before = fs::read(&store)?; assert!(commit_repo_model_admission(&store, &result.result_id, &review).is_err()); assert_eq!(fs::read(&store)?, before); } Ok(()) } #[test] fn repo_model_incorporates_pass_and_nonpass_soul_verdicts_causally() -> Result<()> { for verdict in ["pass", "needs-review", "needs-evidence", "fail"] { let temp = tempdir()?; let fixture = frontier_verdict_fixture(temp.path(), verdict, verdict)?; let (result, review) = incorporation_result_and_review(&fixture, verdict)?; put_runtime_role_worker_result(&fixture.store, &result)?; let receipt = commit_repo_model_admission(&fixture.store, &result.result_id, &review)?; assert_eq!(receipt.purpose, result.repo_model_patch()?.unwrap().purpose); assert_eq!(receipt.frontier_route_id, fixture.route.route_id); assert_eq!(receipt.verification_request_id, fixture.request.request_id); assert_eq!(receipt.soul_verdict_receipt_id, fixture.verdict.receipt_id); assert_eq!( receipt.frontier_modeling_request_id, fixture.modeling_request.request_id ); assert_eq!( commit_repo_model_admission(&fixture.store, &result.result_id, &review)?, receipt ); let mut cache = runtime_spine_cache(&fixture.store)?; cache.pull_all_backing_stores()?; let admitted = cache .get::(crate::MEMORY_GRAPH_KEY)? .unwrap() .snapshot()?; let item = admitted .frontier .iter() .find(|item| item.id == fixture.route.frontier_item_id) .unwrap(); let expected = if verdict == "pass" { crate::RepoFrontierStatus::Resolved } else { crate::RepoFrontierStatus::Blocked }; assert_eq!(item.status, expected); if verdict != "pass" { assert!(!item.gap.trim().is_empty()); } assert!(!runtime_has_actionable_hands_frontier(&fixture.store)?); } Ok(()) } #[test] fn frontier_modeling_request_reloads_exact_accepted_result_despite_adjacent_verdict() -> Result<()> { let temp = tempdir()?; let fixture = frontier_verdict_fixture(temp.path(), "request-adjacency", "pass")?; let adjacent = EpiphanyRuntimeRoleWorkerResult { schema_version: RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.to_string(), repository_body_observation_basis: None, result_id: "adjacent-verification-result".to_string(), job_id: "adjacent-verification-job".to_string(), role_id: "verification".to_string(), verdict: "fail".to_string(), summary: "Nearby but not accepted.".to_string(), next_safe_move: "Remain unselected.".to_string(), checkpoint_summary: None, scratch_summary: None, files_inspected: Vec::new(), frontier_node_ids: Vec::new(), evidence_ids: vec!["adjacent-evidence".to_string()], artifact_refs: Vec::new(), open_questions: Vec::new(), evidence_gaps: Vec::new(), risks: Vec::new(), state_patch_msgpack: None, self_patch_msgpack: None, item_error: None, metadata: BTreeMap::new(), repo_model_patch_msgpack: None, verification_request_id: Some(fixture.request.request_id.clone()), frontier_route_id: Some(fixture.route.route_id.clone()), repo_frontier_modeling_request_id: None, proposal_modeling_request_id: None, claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_candidate_msgpack: None, frontier_plan_mind_request_id: None, frontier_plan_mind_decision_msgpack: None, imagination_consideration_request_id: None, imagination_consideration_candidate_msgpack: None, admitted_model_direction_consideration_request_id: None, admitted_model_direction_consideration_result_msgpack: None, }; put_test_non_modeling_worker_launch(&fixture.store, &adjacent.job_id, "verification")?; put_runtime_role_worker_result(&fixture.store, &adjacent)?; put_soul_verdict_receipt( &fixture.store, &SoulVerdictReceipt { schema_version: SOUL_VERDICT_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: "adjacent-soul-verdict".to_string(), source_result_id: adjacent.result_id.clone(), source_job_id: adjacent.job_id.clone(), verdict: adjacent.verdict.clone(), summary: adjacent.summary.clone(), evidence_ids: adjacent.evidence_ids.clone(), risks: adjacent.risks.clone(), emitted_at: "2026-07-13T06:00:09Z".to_string(), contract: "unaccepted adjacent verdict".to_string(), verification_request_id: fixture.request.request_id.clone(), frontier_route_id: fixture.route.route_id.clone(), }, )?; let accepted = epiphany_state_model::EpiphanyAcceptanceReceipt { id: "verification-acceptance-request-adjacency".to_string(), result_id: "verification-result-request-adjacency".to_string(), job_id: "verification-job-request-adjacency".to_string(), binding_id: "verification-worker".to_string(), surface: "roleAccept".to_string(), role_id: "verification".to_string(), status: "accepted".to_string(), accepted_at: "2026-07-13T06:00:08Z".to_string(), ..Default::default() }; let reloaded = commit_repo_frontier_modeling_request(&fixture.store, &accepted)?; assert_eq!(reloaded, fixture.modeling_request); assert_eq!(reloaded.verification_result_id, accepted.result_id); assert_ne!(reloaded.verification_result_id, adjacent.result_id); Ok(()) } #[test] fn repo_model_verdict_incorporation_refuses_mixed_chains_and_illegal_edits_without_mutation() -> Result<()> { fn attempt( fixture: &FrontierVerdictFixture, suffix: &str, mutate: impl FnOnce(&mut crate::RepoModelPatch), ) -> Result<()> { let (mut result, mut review) = incorporation_result_and_review(fixture, suffix)?; let mut patch = result.repo_model_patch()?.unwrap(); mutate(&mut patch); let bytes = rmp_serde::to_vec_named(&patch)?; result.repo_model_patch_msgpack = Some(bytes.clone()); result.evidence_ids = match &patch.purpose { crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { soul_verdict_receipt_id, .. } => vec![soul_verdict_receipt_id.clone()], crate::RepoModelPatchPurpose::Evolution => vec!["evolution".to_string()], crate::RepoModelPatchPurpose::RepairClaim => vec!["repair".to_string()], crate::RepoModelPatchPurpose::AdoptFrontierPlan { .. } => { vec!["adopt".to_string()] } crate::RepoModelPatchPurpose::RelinquishFrontierRoute { .. } => { vec!["relinquish".to_string()] } }; review.patch_id = patch.patch_id.clone(); review.patch_sha256 = format!("{:x}", Sha256::digest(&bytes)); review.base_revision = patch.base_revision; review.base_hash = patch.base_hash.clone(); review.evidence_ids = result.evidence_ids.clone(); put_runtime_role_worker_result(&fixture.store, &result)?; let before = fs::read(&fixture.store)?; assert!( commit_repo_model_admission(&fixture.store, &result.result_id, &review).is_err() ); assert_eq!(fs::read(&fixture.store)?, before); complete_runtime_job( &fixture.store, RuntimeSpineJobResultOptions { result_id: format!("terminal-{suffix}"), job_id: result.job_id.clone(), completed_at: "2026-07-13T06:00:11Z".into(), verdict: "rejected".into(), summary: "Hostile admission fixture rejected.".into(), next_safe_move: "Launch the next isolated fixture.".into(), evidence_refs: Vec::new(), artifact_refs: Vec::new(), }, )?; let mut cache = runtime_spine_cache(&fixture.store)?; cache.pull_all_backing_stores()?; let entry = cache .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("hostile fixture thread state disappeared"))?; let mut state = entry.state()?; for link in &mut state.runtime_links { if link.runtime_job_id == result.job_id && link.runtime_result_id.is_none() { link.runtime_result_id = Some(format!("terminal-{suffix}")); } } cache.put( crate::THREAD_STATE_KEY, &crate::EpiphanyThreadStateEntry::from_state(entry.thread_id, &state)?, )?; Ok(()) } let temp = tempdir()?; let fixture = frontier_verdict_fixture(temp.path(), "swapped-route", "pass")?; attempt(&fixture, "swapped-route", |patch| { patch.purpose = crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { route_id: "different-route".to_string(), soul_verdict_receipt_id: fixture.verdict.receipt_id.clone(), }; })?; for (suffix, alter) in [ ("swapped-request", "request"), ("swapped-verdict-route", "route"), ("swapped-result", "result"), ] { let case_root = tempdir()?; let fixture = frontier_verdict_fixture(case_root.path(), suffix, "pass")?; let mut counterfeit = fixture.verdict.clone(); counterfeit.receipt_id = format!("counterfeit-{suffix}"); match alter { "request" => counterfeit.verification_request_id = "different-request".to_string(), "route" => counterfeit.frontier_route_id = "different-route".to_string(), "result" => counterfeit.source_result_id = "different-result".to_string(), _ => unreachable!(), } put_soul_verdict_receipt(&fixture.store, &counterfeit)?; attempt(&fixture, suffix, |patch| { patch.purpose = crate::RepoModelPatchPurpose::IncorporateFrontierVerdict { route_id: fixture.route.route_id.clone(), soul_verdict_receipt_id: counterfeit.receipt_id.clone(), }; })?; } let case_root = tempdir()?; let fixture = frontier_verdict_fixture(case_root.path(), "extra-op", "pass")?; attempt(&fixture, "extra-op", |patch| { let item = fixture.current.frontier[0].clone(); patch .operations .push(crate::RepoModelPatchOperation::ReviseFrontier { item }); })?; let case_root = tempdir()?; let fixture = frontier_verdict_fixture(case_root.path(), "wrong-item", "pass")?; attempt(&fixture, "wrong-item", |patch| { let crate::RepoModelPatchOperation::ReviseFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.id = "other-frontier".to_string(); })?; let case_root = tempdir()?; let fixture = frontier_verdict_fixture(case_root.path(), "wrong-status", "pass")?; attempt(&fixture, "wrong-status", |patch| { let crate::RepoModelPatchOperation::ReviseFrontier { item } = &mut patch.operations[0] else { unreachable!() }; item.status = crate::RepoFrontierStatus::Blocked; item.gap = "still blocked".to_string(); })?; Ok(()) } #[test] fn repo_frontier_route_refuses_unadmitted_and_ineligible_models() -> Result<()> { fn admitted_store_with_items( store: &Path, suffix: &str, items: Vec, ) -> Result<()> { if runtime_swarm_binding(store)?.is_none() { bind_test_runtime_swarm(store, &format!("eligibility-swarm-{suffix}"))?; } let bootstrap = repo_model_bootstrap(); let legacy = store.with_extension(format!("{suffix}.legacy.msgpack")); let (mut current, _) = ensure_runtime_repo_model(store, legacy, &bootstrap, "2026-07-13T05:00:00Z")?; for (index, item) in items.into_iter().enumerate() { let identity = format!("{suffix}-{index}"); let (mut result, mut review) = repo_model_result_and_review( store, &format!("eligibility-result-{identity}"), &format!("eligibility-job-{identity}"), ¤t, &format!("eligibility-review-{identity}"), )?; let mut patch: crate::RepoModelPatch = rmp_serde::from_slice(result.repo_model_patch_msgpack.as_deref().unwrap())?; let proposal_id = result.evidence_ids[0].clone(); let mut item = item; item.evidence_refs.push(proposal_id); patch.operations = vec![crate::RepoModelPatchOperation::UpsertFrontier { item }]; let bytes = rmp_serde::to_vec_named(&patch)?; review.patch_sha256 = format!("{:x}", Sha256::digest(&bytes)); result.repo_model_patch_msgpack = Some(bytes); put_runtime_role_worker_result(store, &result)?; commit_repo_model_admission(store, &result.result_id, &review)?; current = runtime_current_repo_model(store)?.expect("admitted model"); } Ok(()) } let unadmitted = tempdir()?; let unadmitted_store = unadmitted.path().join("runtime.msgpack"); initialize_runtime_spine( &unadmitted_store, RuntimeSpineInitOptions { runtime_id: "route-unadmitted".to_string(), display_name: "Route Unadmitted".to_string(), created_at: "2026-07-13T05:00:00Z".to_string(), }, )?; bind_test_runtime_swarm(&unadmitted_store, "route-unadmitted-swarm")?; ensure_runtime_repo_model( &unadmitted_store, unadmitted.path().join("legacy.msgpack"), &repo_model_bootstrap(), "2026-07-13T05:00:00Z", )?; assert!( select_and_commit_repo_frontier_route(&unadmitted_store, "2026-07-13T05:00:01Z") .is_err() ); assert!(!runtime_has_actionable_hands_frontier(&unadmitted_store)?); for (suffix, status) in [ ("proposed", crate::RepoFrontierStatus::Proposed), ("blocked", crate::RepoFrontierStatus::Blocked), ] { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: format!("route-{suffix}"), display_name: suffix.to_string(), created_at: "2026-07-13T05:00:00Z".to_string(), }, )?; admitted_store_with_items( &store, suffix, vec![crate::RepoFrontierItem { id: format!("frontier-{suffix}"), migration_body: "body".to_string(), question: "question".to_string(), gap: "gap".to_string(), target_claim_ids: vec!["claim-runtime-model".to_string()], source_scope: vec!["epiphany-core/src".to_string()], recommended_next_organ: "Hands".to_string(), status, ..Default::default() }], )?; assert!(select_and_commit_repo_frontier_route(&store, "2026-07-13T05:00:02Z").is_err()); assert!(!runtime_has_actionable_hands_frontier(&store)?); } let active = tempdir()?; let active_store = active.path().join("runtime.msgpack"); initialize_runtime_spine( &active_store, RuntimeSpineInitOptions { runtime_id: "route-active".to_string(), display_name: "active".to_string(), created_at: "2026-07-13T05:00:00Z".to_string(), }, )?; admitted_store_with_items( &active_store, "active", vec![crate::RepoFrontierItem { id: "frontier-active".to_string(), migration_body: "body".to_string(), question: "question".to_string(), gap: "gap".to_string(), target_claim_ids: vec!["claim-runtime-model".to_string()], source_scope: vec!["epiphany-core/src".to_string()], recommended_next_organ: "Hands".to_string(), status: crate::RepoFrontierStatus::Active, ..Default::default() }], )?; assert!(runtime_has_actionable_hands_frontier(&active_store)?); assert!(!runtime_has_actionable_eyes_frontier(&active_store)?); assert!( select_and_commit_repo_frontier_route(&active_store, "2026-07-13T05:00:02Z").is_ok() ); let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "route-dependency".to_string(), display_name: "dependency".to_string(), created_at: "2026-07-13T05:00:00Z".to_string(), }, )?; admitted_store_with_items( &store, "dependency", vec![ crate::RepoFrontierItem { id: "dependency".to_string(), migration_body: "dependency".to_string(), question: "pending?".to_string(), gap: "pending".to_string(), target_claim_ids: vec!["claim-runtime-model".to_string()], source_scope: vec!["epiphany-core/src".to_string()], recommended_next_organ: "Eyes".to_string(), status: crate::RepoFrontierStatus::Active, ..Default::default() }, crate::RepoFrontierItem { id: "dependent".to_string(), migration_body: "dependent".to_string(), question: "ready?".to_string(), gap: "dependency unresolved".to_string(), target_claim_ids: vec!["claim-runtime-model".to_string()], source_scope: vec!["epiphany-core/src".to_string()], recommended_next_organ: "Hands".to_string(), dependency_item_ids: vec!["dependency".to_string()], status: crate::RepoFrontierStatus::Active, ..Default::default() }, ], )?; assert!(select_and_commit_repo_frontier_route(&store, "2026-07-13T05:00:02Z").is_err()); assert!(!runtime_has_actionable_hands_frontier(&store)?); assert!(runtime_has_actionable_eyes_frontier(&store)?); Ok(()) } #[test] fn hands_authority_documents_choose_one_immutable_identity_under_race() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "authority-race".to_string(), display_name: "Authority Race".to_string(), created_at: "2026-07-13T05:30:00Z".to_string(), }, )?; let base_grant = crate::substrate_gate_coordinator_implementation_grant( "race-grant".to_string(), "race-job".to_string(), vec!["epiphany-core/src".to_string()], "2026-07-13T05:30:00Z".to_string(), ); let mut other_grant = base_grant.clone(); other_grant.granted_paths = vec!["epiphany-core/tests".to_string()]; let barrier = std::sync::Arc::new(std::sync::Barrier::new(2)); let outcomes = [base_grant.clone(), other_grant.clone()] .into_iter() .map(|grant| { let path = store.clone(); let barrier = barrier.clone(); std::thread::spawn(move || { barrier.wait(); put_substrate_gate_repo_access_grant_receipt(path, &grant) }) }) .collect::>(); assert_eq!( outcomes .into_iter() .map(|outcome| outcome.join().unwrap()) .filter(Result::is_ok) .count(), 1 ); let winner = runtime_substrate_gate_repo_access_grant_receipt(&store, "race-grant")?.unwrap(); let base_intent = HandsActionIntent { schema_version: HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: "race-intent".to_string(), runtime_job_id: winner.runtime_job_id.clone(), binding_id: winner.binding_id.clone(), role: winner.role.clone(), authority_scope: winner.authority_scope.clone(), requested_action: "patch".to_string(), requested_paths: winner.granted_paths.clone(), substrate_gate_grant_receipt_id: winner.receipt_id.clone(), requested_at: "2026-07-13T05:30:01Z".to_string(), contract: "race intent".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; let mut other_intent = base_intent.clone(); other_intent.requested_action = "continueImplementation".to_string(); let barrier = std::sync::Arc::new(std::sync::Barrier::new(2)); let outcomes = [base_intent.clone(), other_intent] .into_iter() .map(|intent| { let path = store.clone(); let barrier = barrier.clone(); std::thread::spawn(move || { barrier.wait(); put_hands_action_intent(path, &intent) }) }) .collect::>(); assert_eq!( outcomes .into_iter() .map(|outcome| outcome.join().unwrap()) .filter(Result::is_ok) .count(), 1 ); let winner_intent = runtime_hands_action_intent(&store, "race-intent")?.unwrap(); let base_review = hands_action_review_for_intent( "race-review".to_string(), &winner_intent, "approved".to_string(), vec![ "patch".to_string(), "command".to_string(), "commit".to_string(), ], vec!["race".to_string()], "2026-07-13T05:30:02Z".to_string(), ); let mut other_review = base_review.clone(); other_review.allowed_operations = vec!["patch".to_string()]; let barrier = std::sync::Arc::new(std::sync::Barrier::new(2)); let outcomes = [base_review, other_review] .into_iter() .map(|review| { let path = store.clone(); let barrier = barrier.clone(); std::thread::spawn(move || { barrier.wait(); put_hands_action_review(path, &review) }) }) .collect::>(); assert_eq!( outcomes .into_iter() .map(|outcome| outcome.join().unwrap()) .filter(Result::is_ok) .count(), 1 ); Ok(()) } #[test] fn repo_frontier_hands_authority_refuses_substitution_and_retries_exactly() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "route-hostile".to_string(), display_name: "Route Hostile".to_string(), created_at: "2026-07-13T06:00:00Z".to_string(), }, )?; let grant = crate::substrate_gate_coordinator_implementation_grant( "route-hostile-grant".to_string(), "route-hostile-job".to_string(), vec!["epiphany-core/src".to_string()], "2026-07-13T06:00:00Z".to_string(), ); put_substrate_gate_repo_access_grant_receipt(&store, &grant)?; let intent = HandsActionIntent { schema_version: HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: "route-hostile-intent".to_string(), runtime_job_id: grant.runtime_job_id.clone(), binding_id: grant.binding_id.clone(), role: grant.role.clone(), authority_scope: grant.authority_scope.clone(), requested_action: "patch".to_string(), requested_paths: grant.granted_paths.clone(), substrate_gate_grant_receipt_id: grant.receipt_id.clone(), requested_at: "2026-07-13T06:00:01Z".to_string(), contract: "test".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; put_hands_action_intent(&store, &intent)?; let review = hands_action_review_for_intent( "route-hostile-review".to_string(), &intent, "approved".to_string(), vec!["patch".to_string()], vec!["test".to_string()], "2026-07-13T06:00:02Z".to_string(), ); put_hands_action_review(&store, &review)?; let (route, authority) = admit_route_and_authorize_hands(&store, &intent, &review, "hostile")?; assert_eq!( select_and_commit_repo_frontier_route(&store, "2026-07-13T04:00:02Z")?, route ); put_repo_frontier_hands_authority(&store, &authority)?; let mutations: Vec> = vec![ Box::new(|a| a.route_id = "swapped-route".to_string()), Box::new(|a| a.model_hash = "0".repeat(64)), Box::new(|a| a.frontier_item_hash = "1".repeat(64)), Box::new(|a| a.requested_paths = vec!["outside".to_string()]), Box::new(|a| a.hands_intent_id = "swapped-intent".to_string()), Box::new(|a| a.hands_review_id = "swapped-review".to_string()), Box::new(|a| a.substrate_grant_receipt_id = "swapped-grant".to_string()), ]; for (index, mutate) in mutations.into_iter().enumerate() { let mut counterfeit = authority.clone(); counterfeit.authority_id = format!("counterfeit-{index}"); mutate(&mut counterfeit); assert!(put_repo_frontier_hands_authority(&store, &counterfeit).is_err()); } Ok(()) } #[test] fn runtime_spine_initializes_sessions_events_and_status() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-05-06T00:00:00Z".to_string(), }, )?; create_runtime_session( &store, RuntimeSpineSessionOptions { session_id: "session-1".to_string(), objective: "Build the spine.".to_string(), created_at: "2026-05-06T00:01:00Z".to_string(), coordinator_note: "Native first.".to_string(), }, )?; append_runtime_event( &store, RuntimeSpineEventOptions { event_id: "event-1".to_string(), occurred_at: "2026-05-06T00:02:00Z".to_string(), event_type: "session.started".to_string(), source: "test".to_string(), session_id: Some("session-1".to_string()), job_id: None, summary: "Session started.".to_string(), }, )?; put_coordinator_run_receipt( &store, &EpiphanyCoordinatorRunReceipt { schema_version: COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: "coordinator-receipt-1".to_string(), session_id: "session-1".to_string(), thread_id: "thread-1".to_string(), mode: "plan".to_string(), status: "planned".to_string(), final_action: "launchModeling".to_string(), final_reason: Some("Modeling should run.".to_string()), step_count: 1, created_at: "2026-05-06T00:03:00Z".to_string(), model_provider: Some("openai-codex".to_string()), runtime_store: store.display().to_string(), artifact_refs: vec!["coordinator-summary.json".to_string()], sealed_artifact_refs: vec!["epiphany-transcript.jsonl".to_string()], metadata: BTreeMap::new(), resident_grant_id: None, resident_launch_digest: None, resident_policy_digest: None, resident_argv_digest: None, resident_objective_digest: None, resident_release_commit: None, resident_release_manifest_digest: None, resident_executable_digest: None, }, )?; let status = runtime_spine_status(&store)?; assert!(status.present); assert_eq!(status.runtime_id.as_deref(), Some("epiphany-test")); assert_eq!(status.sessions, 1); assert_eq!(status.active_sessions, 1); assert_eq!(status.events, 1); let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; assert!( cache .get::("coordinator-receipt-1")? .is_some() ); Ok(()) } #[test] fn runtime_spine_derives_tool_invocation_statuses() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-05-06T00:00:00Z".to_string(), }, )?; let mut cache = runtime_spine_cache(&store)?; cache.put( "intent:done", &EpiphanyToolInvocationIntent::new( "done", "epiphany-tools", "smoke-server", "smoke_tool", "{}", "model-request-1", "Test completed tool call.", "2026-05-06T00:01:00Z", ), )?; cache.put( "intent:pending", &EpiphanyToolInvocationIntent::new( "pending", "epiphany-tools", "smoke-server", "waiting_tool", "{}", "model-request-2", "Test pending tool call.", "2026-05-06T00:02:00Z", ), )?; let mut failed_receipt = EpiphanyToolInvocationReceipt::new( "receipt-done", "done", "epiphany-tools", "smoke-server", "smoke_tool", "failed", "2026-05-06T00:03:00Z", ); failed_receipt.error = Some("smoke server absent".to_string()); cache.put("receipt:done", &failed_receipt)?; let status = runtime_spine_status(&store)?; assert_eq!(status.tool_invocation_intents, 2); assert_eq!(status.tool_invocation_receipts, 1); assert_eq!(status.pending_tool_invocations, 1); let invocations = runtime_tool_invocation_statuses(&store)?; assert_eq!(invocations.len(), 2); assert_eq!(invocations[0].intent_id, "done"); assert_eq!(invocations[0].status, "failed"); assert_eq!(invocations[0].error.as_deref(), Some("smoke server absent")); assert_eq!(invocations[1].intent_id, "pending"); assert_eq!(invocations[1].status, "pending"); assert!(invocations[1].receipt_id.is_none()); Ok(()) } #[test] fn runtime_spine_opens_and_completes_native_jobs() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-05-06T00:00:00Z".to_string(), }, )?; create_runtime_session( &store, RuntimeSpineSessionOptions { session_id: "session-1".to_string(), objective: "Build the job artery.".to_string(), created_at: "2026-05-06T00:01:00Z".to_string(), coordinator_note: "Native jobs.".to_string(), }, )?; let job = create_runtime_job( &store, RuntimeSpineJobOptions { job_id: "job-1".to_string(), session_id: "session-1".to_string(), role: "modeling".to_string(), created_at: "2026-05-06T00:02:00Z".to_string(), summary: "Model the target.".to_string(), artifact_refs: vec!["artifact:modeling-plan".to_string()], }, )?; assert_eq!(job.status, EpiphanyRuntimeJobStatus::Queued); let result = complete_runtime_job( &store, RuntimeSpineJobResultOptions { result_id: "result-1".to_string(), job_id: "job-1".to_string(), completed_at: "2026-05-06T00:03:00Z".to_string(), verdict: "pass".to_string(), summary: "Model is ready.".to_string(), next_safe_move: "Launch verification.".to_string(), evidence_refs: vec!["evidence:model".to_string()], artifact_refs: vec!["artifact:model".to_string()], }, )?; assert_eq!(result.role, "modeling"); let status = runtime_spine_status(&store)?; assert_eq!(status.jobs, 1); assert_eq!(status.open_jobs, 0); assert_eq!(status.job_results, 1); assert_eq!(status.events, 2); let snapshot = runtime_job_snapshot(&store, "job-1")?.expect("completed job snapshot should exist"); assert_eq!(snapshot.job.status, EpiphanyRuntimeJobStatus::Completed); assert_eq!( snapshot .result .as_ref() .map(|result| result.result_id.as_str()), Some("result-1") ); Ok(()) } #[test] fn runtime_spine_persists_mind_gateway_review_receipts() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-05-06T00:00:00Z".to_string(), }, )?; let review = MindGatewayReview { schema_version: crate::MIND_GATEWAY_REVIEW_SCHEMA_VERSION.to_string(), gateway_id: "mind-role-modeling-job-1".to_string(), source_kind: "roleWorkerResult".to_string(), source_role_id: "modeling".to_string(), decision: crate::mind_gateway::MindGatewayDecision::Accept, allowed_effects: vec!["statePatch".to_string()], refused_effects: Vec::new(), reasons: Vec::new(), contract: "Mind review is persisted before state admission.".to_string(), }; put_mind_gateway_review(&store, &review)?; let commit = crate::mind_state_commit_receipt( "mind-commit-1".to_string(), &review, 42, vec!["GraphCheckpoint".to_string()], "2026-05-06T00:04:00Z".to_string(), ); put_mind_state_commit_receipt(&store, &commit)?; let eyes_packet = EyesEvidencePacket { schema_version: crate::EYES_EVIDENCE_PACKET_SCHEMA_VERSION.to_string(), packet_id: "eyes-packet-1".to_string(), source_result_id: "result-1".to_string(), source_job_id: "job-1".to_string(), source_role_id: "research".to_string(), evidence_ids: vec!["ev-1".to_string()], observation_ids: vec!["obs-1".to_string()], source_refs: vec!["src/lib.rs:1".to_string()], summary: "Evidence packet.".to_string(), uncertainty: "none declared".to_string(), emitted_at: "2026-05-06T00:05:00Z".to_string(), contract: "Eyes packet persists as runtime-spine proof.".to_string(), }; put_eyes_evidence_packet(&store, &eyes_packet)?; let substrate_grant = SubstrateGateRepoAccessGrantReceipt { schema_version: crate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION .to_string(), receipt_id: "substrate-grant-1".to_string(), runtime_job_id: "job-1".to_string(), binding_id: "research-source-gather-worker".to_string(), role: "epiphany-eyes".to_string(), authority_scope: "epiphany.role.research".to_string(), granted_operations: vec!["read".to_string(), "snapshot".to_string()], granted_paths: vec![".".to_string()], granted_at: "2026-05-06T00:06:00Z".to_string(), contract: "Substrate Gate grant persists as runtime-spine proof.".to_string(), }; put_substrate_gate_repo_access_grant_receipt(&store, &substrate_grant)?; let soul_verdict = SoulVerdictReceipt { schema_version: crate::SOUL_VERDICT_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: "soul-verdict-1".to_string(), source_result_id: "result-verify-1".to_string(), source_job_id: "job-verify-1".to_string(), verdict: "passed".to_string(), summary: "Verification passed.".to_string(), evidence_ids: vec!["ev-check".to_string()], risks: Vec::new(), emitted_at: "2026-05-06T00:07:00Z".to_string(), contract: "Soul verdict persists as runtime-spine proof.".to_string(), verification_request_id: String::new(), frontier_route_id: String::new(), }; put_soul_verdict_receipt(&store, &soul_verdict)?; let continuity_recovery = ContinuityRecoveryReceipt { schema_version: crate::CONTINUITY_RECOVERY_RECEIPT_SCHEMA_VERSION.to_string(), receipt_id: "continuity-recovery-1".to_string(), source_result_id: "result-reorient-1".to_string(), source_job_id: "job-reorient-1".to_string(), binding_id: "reorientation-worker".to_string(), mode: "resume".to_string(), checkpoint_still_valid: "true".to_string(), summary: "Checkpoint survives.".to_string(), next_safe_move: "Continue.".to_string(), files_inspected: vec!["state/map.yaml".to_string()], emitted_at: "2026-05-06T00:08:00Z".to_string(), contract: "Continuity recovery persists as runtime-spine proof.".to_string(), }; put_continuity_recovery_receipt(&store, &continuity_recovery)?; let stored = runtime_mind_gateway_review(&store, "mind-role-modeling-job-1")? .expect("Mind review receipt should persist"); assert_eq!(stored, review); let stored_commit = runtime_mind_state_commit_receipt(&store, "mind-commit-1")? .expect("Mind state commit receipt should persist"); assert_eq!(stored_commit, commit); let stored_packet = runtime_eyes_evidence_packet(&store, "eyes-packet-1")? .expect("Eyes evidence packet should persist"); assert_eq!(stored_packet, eyes_packet); let stored_grant = runtime_substrate_gate_repo_access_grant_receipt(&store, "substrate-grant-1")? .expect("Substrate Gate grant should persist"); assert_eq!(stored_grant, substrate_grant); let hands_grant = crate::substrate_gate_coordinator_implementation_grant( "substrate-grant-hands-1".to_string(), "job-implementation-1".to_string(), vec!["src/lib.rs".to_string(), "src/unused.rs".to_string()], "2026-05-06T00:06:20Z".to_string(), ); put_substrate_gate_repo_access_grant_receipt(&store, &hands_grant)?; let hands_intent = HandsActionIntent { schema_version: crate::HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: "hands-intent-1".to_string(), runtime_job_id: "job-implementation-1".to_string(), binding_id: "implementation-worker".to_string(), role: "epiphany-hands".to_string(), authority_scope: "epiphany.role.implementation".to_string(), requested_action: "patch".to_string(), requested_paths: vec!["src/lib.rs".to_string(), "src/unused.rs".to_string()], substrate_gate_grant_receipt_id: "substrate-grant-hands-1".to_string(), requested_at: "2026-05-06T00:06:30Z".to_string(), contract: "Hands action intent persists as runtime-spine proof.".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; put_hands_action_intent(&store, &hands_intent)?; let hands_review = crate::hands_action_review_for_intent( "hands-review-1".to_string(), &hands_intent, "approved".to_string(), vec![ "patch".to_string(), "command".to_string(), "commit".to_string(), ], vec!["Substrate Gate grant is present.".to_string()], "2026-05-06T00:06:40Z".to_string(), ); put_hands_action_review(&store, &hands_review)?; put_substrate_gate_repo_access_grant_receipt(&store, &hands_grant)?; put_hands_action_intent(&store, &hands_intent)?; put_hands_action_review(&store, &hands_review)?; let authority_identity_bytes = fs::read(&store)?; let mut counterfeit_grant = hands_grant.clone(); counterfeit_grant.granted_operations = vec!["read".to_string()]; assert!(put_substrate_gate_repo_access_grant_receipt(&store, &counterfeit_grant).is_err()); let mut counterfeit_intent = hands_intent.clone(); counterfeit_intent.requested_action = "command".to_string(); assert!(put_hands_action_intent(&store, &counterfeit_intent).is_err()); let mut counterfeit_review = hands_review.clone(); counterfeit_review.allowed_operations = vec!["command".to_string()]; assert!(put_hands_action_review(&store, &counterfeit_review).is_err()); assert_eq!(fs::read(&store)?, authority_identity_bytes); let (frontier_route, _) = admit_route_and_authorize_hands(&store, &hands_intent, &hands_review, "mind-review")?; let hands_patch = crate::hands_patch_receipt_for_review( "hands-patch-1".to_string(), &hands_intent, &hands_review, vec!["src/lib.rs".to_string()], "Applied focused patch.".to_string(), "2026-05-06T00:06:50Z".to_string(), ); put_hands_patch_receipt(&store, &hands_patch)?; let hands_command = crate::hands_command_receipt_for_review( "hands-command-1".to_string(), &hands_intent, &hands_review, "cargo test".to_string(), "0".to_string(), "artifacts/stdout.log".to_string(), "artifacts/stderr.log".to_string(), "Focused command passed.".to_string(), "2026-05-06T00:07:00Z".to_string(), ); put_hands_command_receipt(&store, &hands_command)?; let hands_commit = crate::hands_commit_receipt_for_review( "hands-commit-1".to_string(), &hands_intent, &hands_review, "abc123".to_string(), "main".to_string(), vec!["src/lib.rs".to_string()], "Committed focused patch.".to_string(), "2026-05-06T00:07:10Z".to_string(), ); put_hands_commit_receipt(&store, &hands_commit)?; let hands_pr = crate::hands_pr_receipt_for_review( "hands-pr-1".to_string(), &hands_intent, &hands_review, &hands_commit, "https://github.com/GameCult/EpiphanyAgent/pull/1".to_string(), "1".to_string(), "Publish focused patch".to_string(), "bifrost-publication-receipt-1".to_string(), "Published focused patch as pull request.".to_string(), "2026-05-06T00:07:20Z".to_string(), ); put_hands_pr_receipt(&store, &hands_pr)?; let stored_intent = runtime_hands_action_intent(&store, "hands-intent-1")? .expect("Hands action intent should persist"); assert_eq!(stored_intent, hands_intent); let stored_review = runtime_hands_action_review(&store, "hands-review-1")? .expect("Hands action review should persist"); assert_eq!(stored_review, hands_review); let stored_patch = runtime_hands_patch_receipt(&store, "hands-patch-1")? .expect("Hands patch receipt should persist"); assert_eq!(stored_patch, hands_patch); let stored_command = runtime_hands_command_receipt(&store, "hands-command-1")? .expect("Hands command receipt should persist"); assert_eq!(stored_command, hands_command); let stored_commit = runtime_hands_commit_receipt(&store, "hands-commit-1")? .expect("Hands commit receipt should persist"); assert_eq!(stored_commit, hands_commit); put_hands_patch_receipt(&store, &hands_patch)?; put_hands_command_receipt(&store, &hands_command)?; put_hands_commit_receipt(&store, &hands_commit)?; let immutable_bytes = fs::read(&store)?; let mut counterfeit_patch = hands_patch.clone(); counterfeit_patch.summary = "counterfeit patch".to_string(); assert!(put_hands_patch_receipt(&store, &counterfeit_patch).is_err()); let mut counterfeit_command = hands_command.clone(); counterfeit_command.summary = "counterfeit command".to_string(); assert!(put_hands_command_receipt(&store, &counterfeit_command).is_err()); let mut counterfeit_commit = hands_commit.clone(); counterfeit_commit.summary = "counterfeit commit".to_string(); assert!(put_hands_commit_receipt(&store, &counterfeit_commit).is_err()); assert_eq!(fs::read(&store)?, immutable_bytes); let stored_pr = runtime_hands_pr_receipt(&store, "hands-pr-1")? .expect("Hands PR receipt should persist"); assert_eq!(stored_pr, hands_pr); assert!(runtime_hands_receipt_chain_after( &store, "2026-05-06T00:06:45Z" )?); let hands_chain = runtime_latest_hands_receipt_chain_after(&store, "2026-05-06T00:06:45Z")? .expect("Hands receipt chain should summarize"); assert_eq!(hands_chain.patch_receipt_id, "hands-patch-1"); assert_eq!(hands_chain.command_receipt_id, "hands-command-1"); assert_eq!(hands_chain.commit_receipt_id, "hands-commit-1"); assert_eq!(hands_chain.exit_code, "0"); let verification_request = commit_repo_frontier_verification_request_for_chain( &store, &hands_chain, "2026-05-06T00:07:11Z", )?; let retried_verification_request = commit_repo_frontier_verification_request_for_chain( &store, &hands_chain, "2026-05-06T00:08:11Z", )?; assert_eq!(retried_verification_request, verification_request); assert_eq!( retried_verification_request.requested_at, "2026-05-06T00:07:11Z" ); assert_eq!(verification_request.route_id, frontier_route.route_id); assert_eq!(verification_request.hands_patch_receipt_id, "hands-patch-1"); assert_eq!( verification_request.hands_command_receipt_id, "hands-command-1" ); assert_eq!( verification_request.hands_commit_receipt_id, "hands-commit-1" ); let bytes_before_hostile_request = fs::read(&store)?; let mut missing_receipt = verification_request.clone(); missing_receipt.request_id = "verification-missing-receipt".to_string(); missing_receipt.hands_command_receipt_id = "missing-command".to_string(); assert!(put_repo_frontier_verification_request(&store, &missing_receipt).is_err()); let mut swapped_route = verification_request.clone(); swapped_route.request_id = "verification-swapped-route".to_string(); swapped_route.route_id = "other-route".to_string(); assert!(put_repo_frontier_verification_request(&store, &swapped_route).is_err()); let mut mixed_chain = verification_request.clone(); mixed_chain.request_id = "verification-mixed-chain".to_string(); mixed_chain.hands_patch_receipt_id = "hands-patch-1".to_string(); mixed_chain.hands_commit_receipt_id = "missing-commit".to_string(); assert!(put_repo_frontier_verification_request(&store, &mixed_chain).is_err()); assert_eq!(fs::read(&store)?, bytes_before_hostile_request); assert!(!runtime_hands_receipt_chain_after( &store, "2026-05-06T00:07:15Z" )?); let stored_verdict = runtime_soul_verdict_receipt(&store, "soul-verdict-1")? .expect("Soul verdict should persist"); assert_eq!(stored_verdict, soul_verdict); let stored_recovery = runtime_continuity_recovery_receipt(&store, "continuity-recovery-1")? .expect("Continuity recovery should persist"); assert_eq!(stored_recovery, continuity_recovery); Ok(()) } #[test] fn verification_consequence_paths_are_a_non_empty_authority_subset() { let authority = vec![ "epiphany-core/src/runtime_spine.rs".to_string(), "epiphany-core/src/surfaces/coordinator.rs".to_string(), ]; assert!(consequence_paths_within_authority( &["epiphany-core/src/runtime_spine.rs".to_string()], &authority, )); assert!(!consequence_paths_within_authority(&[], &authority)); assert!(!consequence_paths_within_authority( &["epiphany-core/src/lib.rs".to_string()], &authority, )); } #[test] fn hands_persistence_requires_resolved_matching_grant_authority() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-07-12T00:00:00Z".to_string(), }, )?; let mut intent = HandsActionIntent { schema_version: crate::HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: "hands-intent-grant-check".to_string(), runtime_job_id: "hands-job-grant-check".to_string(), binding_id: "repo-work-runner".to_string(), role: "epiphany-hands".to_string(), authority_scope: "repo.branch_local_work".to_string(), requested_action: "runAcceptedWorkItem".to_string(), requested_paths: vec!["README.md".to_string()], substrate_gate_grant_receipt_id: "missing-grant".to_string(), requested_at: "2026-07-12T00:00:01Z".to_string(), contract: "Negative grant resolution proof.".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; assert!(put_hands_action_intent(&store, &intent).is_err()); let grant = crate::substrate_gate_repo_work_planning_grant( "planning-grant".to_string(), intent.runtime_job_id.clone(), vec!["notes".to_string()], "2026-07-12T00:00:00Z".to_string(), ); put_substrate_gate_repo_access_grant_receipt(&store, &grant)?; intent.substrate_gate_grant_receipt_id = grant.receipt_id.clone(); assert!(put_hands_action_intent(&store, &intent).is_err()); intent.requested_paths = vec!["notes/a.md".to_string()]; put_hands_action_intent(&store, &intent)?; let review = crate::hands_action_review_for_intent( "hands-review-grant-check".to_string(), &intent, "approved".to_string(), vec!["patch".to_string()], vec!["test".to_string()], "2026-07-12T00:00:02Z".to_string(), ); put_hands_action_review(&store, &review)?; let patch = crate::hands_patch_receipt_for_review( "hands-patch-grant-check".to_string(), &intent, &review, vec!["notes/a.md".to_string()], "test".to_string(), "2026-07-12T00:00:03Z".to_string(), ); assert!(put_hands_patch_receipt(&store, &patch).is_err()); Ok(()) } #[test] fn latest_hands_chain_uses_latest_same_gate_receipts_before_commit() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-06-13T00:00:00Z".to_string(), }, )?; let intent = HandsActionIntent { schema_version: crate::HANDS_ACTION_INTENT_SCHEMA_VERSION.to_string(), intent_id: "hands-intent-reused".to_string(), runtime_job_id: "hands-job-reused".to_string(), binding_id: "implementation-worker".to_string(), role: "epiphany-hands".to_string(), authority_scope: "epiphany.role.implementation".to_string(), requested_action: "continueImplementation".to_string(), requested_paths: vec!["new.rs".to_string(), "old.rs".to_string()], substrate_gate_grant_receipt_id: "substrate-grant-reused".to_string(), requested_at: "2026-06-13T00:00:01Z".to_string(), contract: "Test reused Hands gate.".to_string(), frontier_route_id: String::new(), plan_candidate_sha256: String::new(), plan_action: String::new(), }; put_substrate_gate_repo_access_grant_receipt( &store, &crate::substrate_gate_coordinator_implementation_grant( "substrate-grant-reused".to_string(), "hands-job-reused".to_string(), vec!["new.rs".to_string(), "old.rs".to_string()], "2026-06-13T00:00:00Z".to_string(), ), )?; put_hands_action_intent(&store, &intent)?; let review = crate::hands_action_review_for_intent( "hands-review-reused".to_string(), &intent, "approved".to_string(), vec![ "patch".to_string(), "command".to_string(), "commit".to_string(), ], vec!["test reused gate".to_string()], "2026-06-13T00:00:02Z".to_string(), ); put_hands_action_review(&store, &review)?; admit_route_and_authorize_hands(&store, &intent, &review, "reused")?; put_hands_patch_receipt( &store, &crate::hands_patch_receipt_for_review( "hands-patch-old".to_string(), &intent, &review, vec!["old.rs".to_string()], "old patch".to_string(), "2026-06-13T00:00:03Z".to_string(), ), )?; put_hands_command_receipt( &store, &crate::hands_command_receipt_for_review( "hands-command-old".to_string(), &intent, &review, "cargo test old".to_string(), "0".to_string(), "old-stdout.log".to_string(), "old-stderr.log".to_string(), "old command".to_string(), "2026-06-13T00:00:04Z".to_string(), ), )?; put_hands_commit_receipt( &store, &crate::hands_commit_receipt_for_review( "hands-commit-old".to_string(), &intent, &review, "oldsha".to_string(), "codex/test".to_string(), vec!["old.rs".to_string()], "old commit".to_string(), "2026-06-13T00:00:05Z".to_string(), ), )?; put_hands_patch_receipt( &store, &crate::hands_patch_receipt_for_review( "hands-patch-new".to_string(), &intent, &review, vec!["new.rs".to_string()], "new patch".to_string(), "2026-06-13T00:00:06Z".to_string(), ), )?; put_hands_command_receipt( &store, &crate::hands_command_receipt_for_review( "hands-command-new".to_string(), &intent, &review, "cargo test new".to_string(), "0".to_string(), "new-stdout.log".to_string(), "new-stderr.log".to_string(), "new command".to_string(), "2026-06-13T00:00:07Z".to_string(), ), )?; put_hands_commit_receipt( &store, &crate::hands_commit_receipt_for_review( "hands-commit-new".to_string(), &intent, &review, "newsha".to_string(), "codex/test".to_string(), vec!["new.rs".to_string()], "new commit".to_string(), "2026-06-13T00:00:08Z".to_string(), ), )?; let chain = runtime_latest_hands_receipt_chain_after(&store, "2026-06-13T00:00:02Z")? .expect("latest same-gate Hands chain"); assert_eq!(chain.patch_receipt_id, "hands-patch-new"); assert_eq!(chain.command_receipt_id, "hands-command-new"); assert_eq!(chain.commit_receipt_id, "hands-commit-new"); assert_eq!(chain.command, "cargo test new"); assert_eq!(chain.stdout_artifact, "new-stdout.log"); assert_eq!(chain.commit_sha, "newsha"); assert_eq!(chain.changed_paths, vec!["new.rs".to_string()]); Ok(()) } #[test] fn runtime_spine_opens_heartbeat_job_from_single_typed_call() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); let job = open_runtime_spine_heartbeat_job( &store, RuntimeSpineHeartbeatJobOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), session_id: "epiphany-main".to_string(), objective: "Run heartbeat worker.".to_string(), coordinator_note: "Test launch.".to_string(), job_id: "heartbeat-job-1".to_string(), role: crate::EPIPHANY_RESEARCH_OWNER_ROLE.to_string(), binding_id: "research-worker".to_string(), authority_scope: "research".to_string(), instruction: "Inspect the checkpoint and return typed role findings.".to_string(), launch_document: EpiphanyWorkerLaunchDocument::Role( crate::EpiphanyRoleWorkerLaunchDocument { thread_id: "thread-1".to_string(), role_id: "research".to_string(), state_revision: 7, objective: Some("Run heartbeat worker.".to_string()), dynamic_prompt_context: None, repository_body_observation_basis: None, proposal_modeling_context: None, claim_repair_context: None, frontier_planning_context: None, frontier_plan_mind_context: None, imagination_consideration_context: None, admitted_model_direction_consideration_context: None, active_subgoal_id: None, active_subgoals: Vec::new(), active_graph_node_ids: vec!["node-model".to_string()], investigation_checkpoint: None, scratch: None, invariants: Vec::new(), graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, graph_checkpoint: None, planning: None, churn: None, }, ), output_contract_id: crate::ROLE_WORKER_OUTPUT_CONTRACT_ID.to_string(), organ_launch_contract: crate::default_launch_organ_contract( "research", "role", crate::ROLE_WORKER_OUTPUT_CONTRACT_ID, ), proposal_modeling_request_id: None, claim_repair_request_id: None, frontier_planning_request_id: None, frontier_plan_mind_request_id: None, imagination_consideration_request_id: None, admitted_model_direction_consideration_request_id: None, created_at: "2026-05-06T00:02:00Z".to_string(), }, )?; assert_eq!(job.job_id, "heartbeat-job-1"); assert_eq!(job.session_id, "epiphany-main"); assert_eq!(job.role, crate::EPIPHANY_RESEARCH_OWNER_ROLE); let status = runtime_spine_status(&store)?; assert_eq!(status.sessions, 1); assert_eq!(status.jobs, 1); assert_eq!(status.open_jobs, 1); assert_eq!(status.events, 1); let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let launch_request = cache .get::("heartbeat-job-1")? .expect("typed worker launch request should be durable"); assert_eq!(launch_request.job_id, "heartbeat-job-1"); assert_eq!(launch_request.binding_id, "research-worker"); assert_eq!(launch_request.role, crate::EPIPHANY_RESEARCH_OWNER_ROLE); assert_eq!( launch_request.output_contract_id, crate::ROLE_WORKER_OUTPUT_CONTRACT_ID ); assert_eq!(launch_request.document_kind, "role"); assert!(!launch_request.launch_document_msgpack.is_empty()); assert_eq!(launch_request.launch_document()?.thread_id(), "thread-1"); assert_eq!(launch_request.organ_launch_contract.document_kind, "role"); assert!( !launch_request .organ_launch_contract .receipt_proof_profiles .is_empty() ); Ok(()) } #[test] fn heartbeat_launch_plan_leaves_lifecycle_to_runtime_links() { let launch_plan = plan_runtime_spine_heartbeat_launch( &EpiphanyThreadState::default(), RuntimeSpineHeartbeatLaunchPlanOptions { binding_id: "modeling-checkpoint-worker".to_string(), kind: EpiphanyJobKind::Specialist, scope: "role-scoped modeling/checkpoint maintenance".to_string(), owner_role: "epiphany-modeler".to_string(), authority_scope: "epiphany.role.modeling".to_string(), linked_subgoal_ids: vec!["phase-6".to_string()], linked_graph_node_ids: vec!["runtime-spine".to_string()], instruction: "Model the target before implementation.".to_string(), launch_document: EpiphanyWorkerLaunchDocument::Role( crate::EpiphanyRoleWorkerLaunchDocument { thread_id: "thread-1".to_string(), role_id: "modeling".to_string(), state_revision: 7, objective: Some("keep state typed".to_string()), dynamic_prompt_context: None, repository_body_observation_basis: None, proposal_modeling_context: None, claim_repair_context: None, frontier_planning_context: None, frontier_plan_mind_context: None, imagination_consideration_context: None, admitted_model_direction_consideration_context: None, active_subgoal_id: None, active_subgoals: Vec::new(), active_graph_node_ids: vec!["runtime-spine".to_string()], investigation_checkpoint: None, scratch: None, invariants: Vec::new(), graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, graph_checkpoint: None, planning: None, churn: None, }, ), output_contract_id: crate::ROLE_WORKER_OUTPUT_CONTRACT_ID.to_string(), organ_launch_contract: crate::default_launch_organ_contract( "epiphany.role.modeling", "role", crate::ROLE_WORKER_OUTPUT_CONTRACT_ID, ), max_runtime_seconds: Some(60), runtime_job_id: "turn-1".to_string(), }, ) .expect("launch planning should build binding and runtime link"); assert_eq!( launch_plan.binding.authority_scope.as_deref(), Some("epiphany.role.modeling") ); assert_eq!( launch_plan.runtime_link.id, "runtime-link-modeling-checkpoint-worker-turn-1" ); assert_eq!(launch_plan.runtime_link.runtime_job_id, "turn-1"); assert_eq!(launch_plan.runtime_link.runtime_result_id, None); assert_eq!(launch_plan.runtime_link.role_id, "epiphany-modeler"); } #[test] fn heartbeat_launch_allows_replacement_after_terminal_runtime_link() { let mut state = EpiphanyThreadState::default(); state.runtime_links.push(EpiphanyRuntimeLink { id: "runtime-link-modeling-checkpoint-worker-old".to_string(), binding_id: "modeling-checkpoint-worker".to_string(), surface: "runtimeResult".to_string(), role_id: "epiphany-modeler".to_string(), authority_scope: "epiphany.role.modeling".to_string(), runtime_job_id: "old-turn".to_string(), runtime_result_id: Some("result-old-turn".to_string()), linked_subgoal_ids: Vec::new(), linked_graph_node_ids: Vec::new(), }); state.runtime_links.push(EpiphanyRuntimeLink { id: "runtime-link-modeling-checkpoint-worker-stale-active".to_string(), binding_id: "modeling-checkpoint-worker".to_string(), surface: "jobLaunch".to_string(), role_id: "epiphany-modeler".to_string(), authority_scope: "epiphany.role.modeling".to_string(), runtime_job_id: "stale-turn".to_string(), runtime_result_id: None, linked_subgoal_ids: Vec::new(), linked_graph_node_ids: Vec::new(), }); let launch_plan = plan_runtime_spine_heartbeat_launch( &state, RuntimeSpineHeartbeatLaunchPlanOptions { binding_id: "modeling-checkpoint-worker".to_string(), kind: EpiphanyJobKind::Specialist, scope: "role-scoped modeling/checkpoint maintenance".to_string(), owner_role: "epiphany-modeler".to_string(), authority_scope: "epiphany.role.modeling".to_string(), linked_subgoal_ids: Vec::new(), linked_graph_node_ids: Vec::new(), instruction: "Model the target before implementation.".to_string(), launch_document: EpiphanyWorkerLaunchDocument::Role( crate::EpiphanyRoleWorkerLaunchDocument { thread_id: "thread-1".to_string(), role_id: "modeling".to_string(), state_revision: 7, objective: None, dynamic_prompt_context: None, repository_body_observation_basis: None, proposal_modeling_context: None, claim_repair_context: None, frontier_planning_context: None, frontier_plan_mind_context: None, imagination_consideration_context: None, admitted_model_direction_consideration_context: None, active_subgoal_id: None, active_subgoals: Vec::new(), active_graph_node_ids: Vec::new(), investigation_checkpoint: None, scratch: None, invariants: Vec::new(), graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, graph_checkpoint: None, planning: None, churn: None, }, ), output_contract_id: crate::ROLE_WORKER_OUTPUT_CONTRACT_ID.to_string(), organ_launch_contract: crate::default_launch_organ_contract( "epiphany.role.modeling", "role", crate::ROLE_WORKER_OUTPUT_CONTRACT_ID, ), max_runtime_seconds: Some(60), runtime_job_id: "new-turn".to_string(), }, ) .expect("terminal runtime links should not block replacement launch"); assert_eq!(launch_plan.runtime_link.runtime_job_id, "new-turn"); } #[test] fn runtime_spine_emits_cultnet_hello_frame() -> Result<()> { let temp = tempdir()?; let store = temp.path().join("runtime.msgpack"); initialize_runtime_spine( &store, RuntimeSpineInitOptions { runtime_id: "epiphany-test".to_string(), display_name: "Epiphany Test".to_string(), created_at: "2026-05-06T00:00:00Z".to_string(), }, )?; let mut cache = runtime_spine_cache(&store)?; cache.pull_all_backing_stores()?; let mut legacy_identity = cache.get_required::(RUNTIME_IDENTITY_KEY)?; legacy_identity .supported_document_types .push("epiphany.surface.persona".to_string()); cache.put(RUNTIME_IDENTITY_KEY, &legacy_identity)?; let frame = runtime_hello_frame(&store)?; let payload_len = u32::from_be_bytes([frame[0], frame[1], frame[2], frame[3]]) as usize; let message = decode_cultnet_message_from_slice(&frame[4..], CultNetWireContract::CultNetSchemaV0)?; assert_eq!(payload_len, frame.len() - 4); match message { CultNetMessage::Hello { runtime_id, runtime_kind, supported_document_types, supported_mutation_contracts, .. } => { assert_eq!(runtime_id, "epiphany-test"); assert_eq!(runtime_kind, "epiphany.native"); let supported_document_types = supported_document_types.unwrap(); assert!(supported_document_types.contains(&RUNTIME_JOB_RESULT_TYPE.to_string())); assert!( supported_document_types .iter() .all(|document_type| !document_type.starts_with("epiphany.surface.")), "Hello must advertise only runtime-backed document capabilities" ); let contracts = supported_mutation_contracts.unwrap(); assert!( contracts.iter().all(|contract| { !contract.document_type.starts_with("epiphany.surface.") }), "schema vocabulary is not runtime mutation authority" ); let heartbeat_contract = contracts .iter() .find(|contract| contract.document_type == HEARTBEAT_STATE_TYPE) .expect("heartbeat state should advertise mutation contract"); assert_eq!( heartbeat_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( heartbeat_contract .operations .contains(&CultNetDocumentOperation::IntentSubmit) ); assert!( heartbeat_contract .intent_document_types .as_ref() .is_some_and(|items| items .iter() .any(|item| item == "epiphany.heartbeat_heat_intent.v0")) ); let mind_state_contract = contracts .iter() .find(|contract| contract.document_type == MIND_STATE_EFFECT_PROPOSAL_TYPE) .expect("Mind state-effect proposal should advertise a mutation contract"); assert_eq!( mind_state_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( mind_state_contract .receipt_document_types .as_ref() .is_some_and(|items| items .iter() .any(|item| item == MIND_STATE_COMMIT_RECEIPT_TYPE)) ); assert!(mind_state_contract.notes.as_ref().is_some_and(|notes| { notes .iter() .any(|note| note.contains("persistent state guardian")) })); let substrate_gate_repo_contract = contracts .iter() .find(|contract| { contract.document_type == SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE }) .expect("Substrate Gate repo access should advertise a mutation contract"); assert_eq!( substrate_gate_repo_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( substrate_gate_repo_contract .receipt_document_types .as_ref() .is_some_and(|items| items .iter() .any(|item| item == SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE)) ); assert!( substrate_gate_repo_contract .notes .as_ref() .is_some_and(|notes| { notes .iter() .any(|note| note.contains("repository access protocol")) }) ); let eyes_evidence_contract = contracts .iter() .find(|contract| contract.document_type == EYES_EVIDENCE_REQUEST_TYPE) .expect("Eyes evidence request should advertise a mutation contract"); assert_eq!( eyes_evidence_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( eyes_evidence_contract .receipt_document_types .as_ref() .is_some_and(|items| items .iter() .any(|item| item == EYES_EVIDENCE_PACKET_TYPE)) ); assert!(eyes_evidence_contract.notes.as_ref().is_some_and(|notes| { notes .iter() .any(|note| note.contains("evidence ingress guardian")) })); let operator_snapshot_contract = contracts .iter() .find(|contract| { contract.document_type == EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE }) .expect("operator snapshot should advertise a local typed receipt document"); assert_eq!( operator_snapshot_contract.authority, CultNetMutationAuthority::LocalUser ); assert!( operator_snapshot_contract .operations .contains(&CultNetDocumentOperation::DocumentPut) ); let operator_run_intent_contract = contracts .iter() .find(|contract| { contract.document_type == EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE }) .expect("operator run intent should advertise a local typed action document"); assert_eq!( operator_run_intent_contract.authority, CultNetMutationAuthority::LocalUser ); assert!( operator_run_intent_contract .receipt_document_types .as_ref() .is_some_and(|items| items .iter() .any(|item| item == EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE)) ); let operator_run_receipt_contract = contracts .iter() .find(|contract| { contract.document_type == EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE }) .expect("operator run receipt should advertise a local typed receipt document"); assert!( operator_run_receipt_contract .operations .contains(&CultNetDocumentOperation::ReceiptWatch) ); let coordinator_run_receipt_contract = contracts .iter() .find(|contract| contract.document_type == COORDINATOR_RUN_RECEIPT_TYPE) .expect("coordinator run receipt should advertise typed receipt contract"); assert_eq!( coordinator_run_receipt_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( coordinator_run_receipt_contract .operations .contains(&CultNetDocumentOperation::ReceiptWatch) ); let model_contract = contracts .iter() .find(|contract| contract.document_type == MODEL_REQUEST_TYPE) .expect("model adapter should advertise provider-neutral request contract"); assert_eq!( model_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( model_contract .receipt_document_types .as_ref() .is_some_and(|items| items.iter().any(|item| item == MODEL_RECEIPT_TYPE)) ); let openai_contract = contracts .iter() .find(|contract| contract.document_type == OPENAI_MODEL_REQUEST_TYPE) .expect("OpenAI adapter should advertise typed provider evidence contract"); assert_eq!( openai_contract.authority, CultNetMutationAuthority::ReadOnly ); assert!(openai_contract.notes.as_ref().is_some_and(|notes| { notes.iter().any(|note| note.contains("adapter projection")) })); let tool_intent_contract = contracts .iter() .find(|contract| contract.document_type == TOOL_INVOCATION_INTENT_TYPE) .expect("tool invocation intent should advertise typed adapter contract"); assert_eq!( tool_intent_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( tool_intent_contract .receipt_document_types .as_ref() .is_some_and(|items| items .iter() .any(|item| item == TOOL_INVOCATION_RECEIPT_TYPE)) ); let memory_graph_contract = contracts .iter() .find(|contract| contract.document_type == MEMORY_GRAPH_TYPE) .expect("memory graph should advertise a read-only contract"); assert_eq!( memory_graph_contract.authority, CultNetMutationAuthority::ReadOnly ); let thread_state_contract = contracts .iter() .find(|contract| contract.document_type == THREAD_STATE_TYPE) .expect("thread state should advertise a read-only contract"); assert_eq!( thread_state_contract.authority, CultNetMutationAuthority::ReadOnly ); } other => panic!("expected hello, got {other:?}"), } Ok(()) } #[test] fn schema_catalog_discovers_surface_vocabulary_separately_from_runtime_capabilities() -> Result<()> { let registry = epiphany_schema_registry()?; let schemas = registry.list(&cultnet_rs::CultNetSchemaCatalogOptions { include_schema_json: false, schema_ids: None, kinds: None, }); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.surface.scene") && schema.schema_version.as_deref() == Some("epiphany.scene_surface.v0") })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.surface.coordinator") && schema.schema_version.as_deref() == Some("epiphany.coordinator_surface.v0") })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.role_launch_intent.v0") && schema.schema_version.as_deref() == Some("epiphany.role_launch_intent.v0") })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.heartbeat_initiative_heat.v0") && schema.schema_version.as_deref() == Some("epiphany.heartbeat_initiative_heat.v0") })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.heartbeat_heat_intent.v0") && schema.schema_version.as_deref() == Some("epiphany.heartbeat_heat_intent.v0") })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.swarm_control_receipt.v0") && schema.schema_version.as_deref() == Some("epiphany.swarm_control_receipt.v0") })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(COORDINATOR_RUN_RECEIPT_TYPE) && schema.schema_version.as_deref() == Some(COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(MODEL_REQUEST_TYPE) && schema.schema_version.as_deref() == Some(MODEL_REQUEST_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(MODEL_RECEIPT_TYPE) && schema.schema_version.as_deref() == Some(MODEL_RECEIPT_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(TOOL_INVOCATION_INTENT_TYPE) && schema.schema_version.as_deref() == Some(TOOL_INVOCATION_INTENT_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(TOOL_INVOCATION_RECEIPT_TYPE) && schema.schema_version.as_deref() == Some(TOOL_INVOCATION_RECEIPT_SCHEMA_VERSION) })); let receipt_schema_path = epiphany_schema_root().join("epiphany.swarm-control-receipt.schema.json"); let receipt_schema: serde_json::Value = serde_json::from_str(&fs::read_to_string(receipt_schema_path)?)?; let required = receipt_schema["required"] .as_array() .expect("receipt schema should list required fields"); assert!(required.iter().any(|field| field == "decisionOwner")); assert!(required.iter().any(|field| field == "transportRole")); assert!( receipt_schema["properties"]["decisionOwner"]["description"] .as_str() .is_some_and(|description| description.contains("epiphany-core")) ); assert!( receipt_schema["properties"]["transportRole"]["description"] .as_str() .is_some_and(|description| description.contains("must not make")) ); assert!( receipt_schema["properties"]["hostExecutorRole"]["description"] .as_str() .is_some_and(|description| description.contains("gathered facts")) ); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(OPENAI_MODEL_REQUEST_TYPE) && schema.schema_version.as_deref() == Some(OPENAI_MODEL_REQUEST_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(OPENAI_MODEL_RECEIPT_TYPE) && schema.schema_version.as_deref() == Some(OPENAI_MODEL_RECEIPT_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(MEMORY_GRAPH_TYPE) && schema.schema_version.as_deref() == Some(MEMORY_GRAPH_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(THREAD_STATE_TYPE) && schema.schema_version.as_deref() == Some(THREAD_STATE_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE) && schema.schema_version.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE) && schema.schema_version.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION) })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE) && schema.schema_version.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION) })); assert!( !schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.surface.rider_bridge") }), "Rider bridge schema is quarantined and should not be advertised in the active catalog" ); assert!( !schemas.iter().any(|schema| { schema.document_type.as_deref() == Some("epiphany.surface.unity_bridge") }), "Unity bridge schema is quarantined and should not be advertised in the active catalog" ); Ok(()) } }