GameCult/Epiphany
Archived
Watch
9
0
Fork
You've already forked Epiphany
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Delete dormant claim repair authority

Browse source
This commit is contained in:
Meta Vens 2026-08-17 22:22:23 +02:00
commit 20dd66c84b
14 changed files with 53 additions and 674 deletions
Download patch file Download diff file Expand all files Collapse all files

6
epiphany-core/src/agent_launch.rs
View file

@ -1111,7 +1111,6 @@ pub fn build_epiphany_frontier_plan_mind_launch_request(
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -1159,7 +1158,6 @@ pub fn build_epiphany_frontier_plan_mind_launch_request(
organ_launch_contract,
max_runtime_seconds,
proposal_modeling_request_id: None,
claim_repair_request_id: None,
frontier_planning_request_id: None,
frontier_plan_mind_request_id: Some(mind_request_id),
imagination_consideration_request_id: None,
@ -1215,7 +1213,6 @@ pub fn build_epiphany_role_launch_request_with_dynamic_context(
dynamic_prompt_context,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -1262,7 +1259,6 @@ pub fn build_epiphany_role_launch_request_with_dynamic_context(
organ_launch_contract,
max_runtime_seconds,
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,
@ -1428,7 +1424,6 @@ pub fn build_epiphany_job_launch_request(
organ_launch_contract,
max_runtime_seconds,
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,
@ -1688,7 +1683,6 @@ mod tests {
"repositoryBodyObservationBasis",
"repoFrontierModelingRequestId",
"proposalModelingRequestId",
"claimRepairRequestId",
] {
assert!(schema["properties"].get(runtime_owned).is_none());
}

7
epiphany-core/src/coordinator_acceptance.rs
View file

@ -310,7 +310,6 @@ pub fn accept_coordinator_role_finding(
return Err(anyhow::anyhow!("Modeling finding/result identity mismatch"));
}
let is_body_modeling = result.proposal_modeling_request_id.is_none()
&& result.claim_repair_request_id.is_none()
&& result.repo_frontier_modeling_request_id.is_none();
if is_body_modeling {
crate::accept_body_modeling_result(store, job_id, &accepted_at)?;
@ -347,11 +346,7 @@ pub fn accept_coordinator_role_finding(
));
}
let plan = plan_repo_model_mutation(store, &proposal)?;
let invariant_owner = if result.claim_repair_request_id.is_some() {
"Modeling.claim_repair"
} else {
"Modeling.frontier_verdict"
};
let invariant_owner = "Modeling.frontier_verdict";
match commit_mind_mutation(
store,
&result.decision_context_id,

130
epiphany-core/src/coordinator_launch.rs
View file

@ -107,33 +107,6 @@ fn commit_coordinator_job_launch_in_cache(
}
}
}
let claim_repair_launch = if let Some(request_id) = request.claim_repair_request_id.as_deref() {
let (repair, challenge, identity) =
validate_claim_repair_launch(cache, current_state, request, request_id)?;
let projection = RepoModelClaimRepairContextProjection::from_request(&repair);
match &mut effective_launch_document {
EpiphanyWorkerLaunchDocument::Role(document) => {
if document.proposal_modeling_context.is_some() {
return Err(anyhow!(
"claim repair and proposal contexts are mutually exclusive"
));
}
document.claim_repair_context = Some(projection);
}
EpiphanyWorkerLaunchDocument::Reorient(_) => {
return Err(anyhow!("reorient launch cannot carry claim repair context"));
}
}
let bytes = rmp_serde::to_vec_named(&effective_launch_document)?;
Some((
repair,
challenge,
identity,
format!("{:x}", Sha256::digest(bytes)),
))
} else {
None
};
let frontier_planning_launch =
if let Some(request_id) = request.frontier_planning_request_id.as_deref() {
let (planning, identity, attempt_ordinal, superseded_failure_result_id) =
@ -141,9 +114,7 @@ fn commit_coordinator_job_launch_in_cache(
let projection = RepoFrontierPlanningContextProjection::from_request(&planning);
match &mut effective_launch_document {
EpiphanyWorkerLaunchDocument::Role(document) => {
if document.proposal_modeling_context.is_some()
|| document.claim_repair_context.is_some()
{
if document.proposal_modeling_context.is_some() {
return Err(anyhow!(
"frontier planning context is exclusive of Modeling authority contexts"
));
@ -182,7 +153,6 @@ fn commit_coordinator_job_launch_in_cache(
match &mut effective_launch_document {
EpiphanyWorkerLaunchDocument::Role(document) => {
if document.proposal_modeling_context.is_some()
|| document.claim_repair_context.is_some()
|| document.frontier_planning_context.is_some()
|| document.frontier_plan_mind_context.is_some()
{
@ -256,7 +226,6 @@ fn commit_coordinator_job_launch_in_cache(
match &mut effective_launch_document {
EpiphanyWorkerLaunchDocument::Role(document) => {
if document.proposal_modeling_context.is_some()
|| document.claim_repair_context.is_some()
|| document.frontier_planning_context.is_some()
|| document.frontier_plan_mind_context.is_some()
{
@ -315,7 +284,6 @@ fn commit_coordinator_job_launch_in_cache(
output_contract_id: request.output_contract_id.clone(),
organ_launch_contract: request.organ_launch_contract.clone(),
proposal_modeling_request_id: request.proposal_modeling_request_id.clone(),
claim_repair_request_id: request.claim_repair_request_id.clone(),
frontier_planning_request_id: request.frontier_planning_request_id.clone(),
frontier_plan_mind_request_id: request.frontier_plan_mind_request_id.clone(),
imagination_consideration_request_id: request
@ -341,36 +309,6 @@ fn commit_coordinator_job_launch_in_cache(
})
.ok_or_else(|| anyhow!("prepared launch omitted its runtime identity replacement"))?;
let runtime_identity_replacement = batch.remove(runtime_identity_position);
if let Some((repair, challenge, identity, worker_launch_document_sha256)) = claim_repair_launch
{
let launch_binding = RepoModelClaimRepairLaunchBinding {
schema_version: REPO_MODEL_CLAIM_REPAIR_LAUNCH_BINDING_SCHEMA_VERSION.into(),
binding_record_id: format!("repo-model-claim-repair-launch-{}", repair.request_id),
repair_request_id: repair.request_id,
challenge_id: challenge.challenge_id,
challenge_sha256: repair.challenge_sha256,
job_id: plan.backend_job_id.clone(),
binding_id: request.binding_id.clone(),
runtime_id: identity.runtime_id,
thread_id: repair.thread_id,
launched_at: created_at.clone(),
worker_launch_document_sha256,
contract: REPO_MODEL_CLAIM_REPAIR_LAUNCH_BINDING_CONTRACT.into(),
};
if cache
.get::<RepoModelClaimRepairLaunchBinding>(&launch_binding.binding_record_id)?
.is_some()
{
return Err(anyhow!(
"claim repair launch binding already exists for backend job"
));
}
batch.push(
cache
.prepare_entry(&launch_binding.binding_record_id, &launch_binding)?
.0,
);
}
if let Some((
planning,
identity,
@ -532,19 +470,17 @@ pub fn plan_coordinator_job_launch(
}
let (
caller_proposal_projection,
caller_repair_projection,
caller_planning_projection,
caller_mind_projection,
caller_body_basis,
) = match &request.launch_document {
EpiphanyWorkerLaunchDocument::Role(document) => (
document.proposal_modeling_context.as_ref(),
document.claim_repair_context.as_ref(),
document.frontier_planning_context.as_ref(),
document.frontier_plan_mind_context.as_ref(),
document.repository_body_observation_basis.as_ref(),
),
EpiphanyWorkerLaunchDocument::Reorient(_) => (None, None, None, None, None),
EpiphanyWorkerLaunchDocument::Reorient(_) => (None, None, None, None),
};
if caller_body_basis.is_some() {
return Err(anyhow!(
@ -556,11 +492,6 @@ pub fn plan_coordinator_job_launch(
"caller-prepopulated proposal Modeling context is forbidden; coordinator commit owns projection"
));
}
if caller_repair_projection.is_some() {
return Err(anyhow!(
"caller-prepopulated claim repair context is forbidden; coordinator commit owns projection"
));
}
if caller_planning_projection.is_some() {
return Err(anyhow!(
"caller-prepopulated frontier planning context is forbidden; coordinator commit owns projection"
@ -573,7 +504,6 @@ pub fn plan_coordinator_job_launch(
}
if [
request.proposal_modeling_request_id.is_some(),
request.claim_repair_request_id.is_some(),
request.frontier_planning_request_id.is_some(),
request.frontier_plan_mind_request_id.is_some(),
]
@ -594,11 +524,7 @@ pub fn plan_coordinator_job_launch(
state.revision
));
}
if let Some(request_id) = request.claim_repair_request_id.as_deref() {
let mut cache = runtime_spine_cache(runtime_store)?;
cache.pull_all_backing_stores()?;
validate_claim_repair_launch(&cache, state, request, request_id)?;
} else if let Some(request_id) = request.frontier_planning_request_id.as_deref() {
if let Some(request_id) = request.frontier_planning_request_id.as_deref() {
let mut cache = runtime_spine_cache(runtime_store)?;
cache.pull_all_backing_stores()?;
validate_frontier_planning_launch(&cache, state, request, request_id)?;
@ -958,7 +884,6 @@ fn validate_admitted_model_direction_consideration_launch(
|| launch.imagination_consideration_request_id.is_some()
|| launch.frontier_planning_request_id.is_some()
|| launch.frontier_plan_mind_request_id.is_some()
|| launch.claim_repair_request_id.is_some()
|| launch.proposal_modeling_request_id.is_some()
{
return Err(anyhow!(
@ -1001,55 +926,6 @@ fn validate_admitted_model_direction_consideration_launch(
Ok(request)
}
fn validate_claim_repair_launch(
cache: &CultCache,
state: &EpiphanyThreadState,
launch: &EpiphanyJobLaunchRequest,
request_id: &str,
) -> Result<(
RepoModelClaimRepairRequest,
RepoModelClaimChallenge,
EpiphanyRuntimeIdentity,
)> {
if launch.owner_role != EPIPHANY_MODELING_OWNER_ROLE
|| launch.binding_id != EPIPHANY_MODELING_ROLE_BINDING_ID
{
return Err(anyhow!(
"claim repair may only be carried by the Modeling role launch"
));
}
let repair = cache
.get::<RepoModelClaimRepairRequest>(request_id)?
.ok_or_else(|| anyhow!("claim repair request {request_id:?} does not exist"))?;
let challenge = cache
.get::<RepoModelClaimChallenge>(&repair.challenge_id)?
.ok_or_else(|| anyhow!("claim repair launch references a missing challenge"))?;
let identity = cache
.get::<EpiphanyRuntimeIdentity>(RUNTIME_IDENTITY_KEY)?
.ok_or_else(|| anyhow!("claim repair launch requires runtime identity"))?;
let persisted_state = cache
.get::<crate::EpiphanyThreadStateEntry>(crate::THREAD_STATE_KEY)?
.ok_or_else(|| anyhow!("claim repair launch requires authoritative thread state"))?;
let persisted_state_value = persisted_state.state()?;
crate::runtime_spine::validate_current_repo_model_claim_repair_request(cache, &repair)?;
if repair.request_id != request_id
|| repair.runtime_id != identity.runtime_id
|| repair.thread_id != persisted_state.thread_id
|| persisted_state_value != *state
|| launch.launch_document.thread_id() != repair.thread_id
{
return Err(anyhow!("claim repair launch provenance binding mismatch"));
}
if cache
.get_all::<RepoModelClaimRepairLaunchBinding>()?
.iter()
.any(|binding| binding.repair_request_id == request_id)
{
return Err(anyhow!("claim repair request is already bound to a launch"));
}
Ok((repair, challenge, identity))
}
fn worker_attempt_is_retryable_terminal_failure(cache: &CultCache, job_id: &str) -> Result<bool> {
cache
.get::<crate::EpiphanyRuntimeWorkerProcessClaim>(&format!(

3
epiphany-core/src/coordinator_launch_context.rs
View file

@ -1774,7 +1774,6 @@ mod tests {
output_contract_id: launch_request.output_contract_id.clone(),
organ_launch_contract: launch_request.organ_launch_contract.clone(),
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,
@ -2133,7 +2132,6 @@ mod tests {
output_contract_id: verification_launch.output_contract_id,
organ_launch_contract: verification_launch.organ_launch_contract,
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,
@ -2175,7 +2173,6 @@ mod tests {
frontier_route_id: Some(verification_request.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,

44
epiphany-core/src/current_work.rs
View file

@ -521,7 +521,6 @@ pub fn accept_body_modeling_result(
.ok_or_else(|| anyhow!("Body Modeling acceptance lost its typed result"))?;
if result.role_id != "modeling"
|| result.proposal_modeling_request_id.is_some()
|| result.claim_repair_request_id.is_some()
|| result.repo_frontier_modeling_request_id.is_some()
{
return Err(anyhow!("result is not baseline Body Modeling authority"));
@ -599,7 +598,6 @@ pub fn accept_proposal_modeling_result(
.as_deref()
.ok_or_else(|| anyhow!("result is not proposal Modeling authority"))?;
if !result.role_id.eq_ignore_ascii_case("modeling")
|| result.claim_repair_request_id.is_some()
|| result.repo_frontier_modeling_request_id.is_some()
{
return Err(anyhow!("proposal Modeling result crossed family authority"));
@ -682,13 +680,32 @@ pub fn launch_current_body_modeling_work(
{
return Err(anyhow!("Body Modeling launch options are invalid"));
}
let current_work = project_current_work(store_path)?;
let work = current_work
.body_modeling
.ok_or_else(|| anyhow!("Mind has no unresolved Body Modeling work"))?;
let mind = crate::assemble_mind_view(store_path)?;
let body_basis = mind
.repository_body_observation
.clone()
.ok_or_else(|| anyhow!("Mind has no admitted repository Body observation"))?;
let repo_model = mind
.repo_model
.as_ref()
.ok_or_else(|| anyhow!("Mind has no keyed RepoModel state"))?;
let work = EpiphanyBodyModelingWorkProjection::derive(
mind.runtime_id.clone(),
body_basis,
repo_model.reasoning_basis(),
)?;
let mut cache = crate::runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
let mind = crate::assemble_mind_view(store_path)?;
if resolve_body_modeling_work(
work.clone(),
cache.get::<EpiphanyBodyModelingDecisionReceipt>(&work.work_id)?,
)?
.is_none()
|| body_modeling_continuation_action(&cache, &work.work_id)?
!= EpiphanyModelingContinuationAction::Launch
{
return Err(anyhow!("Mind has no launchable Body Modeling work"));
}
let body_source = mind
.source_documents
.iter()
@ -718,7 +735,6 @@ pub fn launch_current_body_modeling_work(
dynamic_prompt_context: None,
repository_body_observation_basis: Some(work.body_basis.clone()),
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -763,7 +779,6 @@ pub fn launch_current_body_modeling_work(
&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,
@ -829,12 +844,11 @@ pub fn launch_current_proposal_modeling_work(
if chrono::DateTime::parse_from_rfc3339(&options.created_at).is_err() {
return Err(anyhow!("proposal Modeling launch options are invalid"));
}
let work = project_current_work(store_path)?
.proposal_modeling
.filter(|work| work.action == EpiphanyModelingContinuationAction::Launch)
.ok_or_else(|| anyhow!("Mind has no launchable proposal Modeling work"))?;
let mut cache = crate::runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
let work = current_proposal_modeling_work(&cache)?
.filter(|work| work.action == EpiphanyModelingContinuationAction::Launch)
.ok_or_else(|| anyhow!("Mind has no launchable proposal Modeling work"))?;
let request = work.request;
let proposal = cache
.get::<crate::RepoFrontierWorkProposal>(&request.proposal_id)?
@ -890,7 +904,6 @@ pub fn launch_current_proposal_modeling_work(
dynamic_prompt_context: None,
repository_body_observation_basis: Some(body_basis),
proposal_modeling_context: Some(proposal_context),
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -938,7 +951,6 @@ pub fn launch_current_proposal_modeling_work(
&output_contract_id,
),
proposal_modeling_request_id: Some(request.request_id.clone()),
claim_repair_request_id: None,
frontier_planning_request_id: None,
frontier_plan_mind_request_id: None,
imagination_consideration_request_id: None,
@ -1331,7 +1343,6 @@ mod tests {
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,
@ -1584,7 +1595,6 @@ mod tests {
frontier_route_id: None,
repo_frontier_modeling_request_id: None,
proposal_modeling_request_id: Some(request.request_id.clone()),
claim_repair_request_id: None,
frontier_planning_request_id: None,
frontier_plan_candidate_msgpack: None,
frontier_plan_mind_request_id: None,

4
epiphany-core/src/lib.rs
View file

@ -1076,7 +1076,6 @@ pub use runtime_spine::commit_repo_frontier_plan_decision;
pub use runtime_spine::commit_repo_frontier_plan_mind_request;
pub use runtime_spine::commit_repo_frontier_verification_request_for_chain;
pub use runtime_spine::commit_repo_model_claim_challenge;
pub use runtime_spine::commit_repo_model_claim_repair_request;
pub use runtime_spine::complete_runtime_job;
pub use runtime_spine::coordinator_run_receipts;
pub use runtime_spine::coordinator_run_session_id;
@ -1325,14 +1324,11 @@ pub use surfaces::REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_CONTRACT;
pub use surfaces::REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_SCHEMA_VERSION;
pub use surfaces::REPO_FRONTIER_RESEARCH_CONTEXT_CONTRACT;
pub use surfaces::REPO_FRONTIER_RESEARCH_CONTEXT_SCHEMA_VERSION;
pub use surfaces::REPO_MODEL_CLAIM_REPAIR_CONTEXT_CONTRACT;
pub use surfaces::REPO_MODEL_CLAIM_REPAIR_CONTEXT_SCHEMA_VERSION;
pub use surfaces::ROLE_WORKER_OUTPUT_CONTRACT_ID;
pub use surfaces::RepoFrontierPlanMindContextProjection;
pub use surfaces::RepoFrontierPlanningContextProjection;
pub use surfaces::RepoFrontierProposalModelingContextProjection;
pub use surfaces::RepoFrontierResearchContextProjection;
pub use surfaces::RepoModelClaimRepairContextProjection;
pub use surfaces::build_reorient_acceptance_bundle;
pub use surfaces::build_reorient_job_launch_request;
pub use surfaces::build_role_acceptance_bundle;

4
epiphany-core/src/reasoning_context.rs
View file

@ -30,7 +30,6 @@ pub struct EpiphanyRolePassAuthorityProjection {
pub dynamic_prompt_context: Option<String>,
pub repository_body_observation_basis: Option<crate::RepositoryBodyObservationBasis>,
pub proposal_modeling_context: Option<crate::RepoFrontierProposalModelingContextProjection>,
pub claim_repair_context: Option<crate::RepoModelClaimRepairContextProjection>,
pub frontier_planning_context: Option<crate::RepoFrontierPlanningContextProjection>,
pub frontier_research_context: Option<crate::RepoFrontierResearchContextProjection>,
pub frontier_plan_mind_context: Option<crate::RepoFrontierPlanMindContextProjection>,
@ -47,7 +46,6 @@ impl From<EpiphanyRoleWorkerLaunchDocument> for EpiphanyRolePassAuthorityProject
dynamic_prompt_context: value.dynamic_prompt_context,
repository_body_observation_basis: value.repository_body_observation_basis,
proposal_modeling_context: value.proposal_modeling_context,
claim_repair_context: value.claim_repair_context,
frontier_planning_context: value.frontier_planning_context,
frontier_research_context: value.frontier_research_context,
frontier_plan_mind_context: value.frontier_plan_mind_context,
@ -1213,7 +1211,6 @@ mod tests {
dynamic_prompt_context: Some("typed projection".into()),
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -1254,7 +1251,6 @@ mod tests {
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,

92
epiphany-core/src/repo_model_gateway.rs
View file

@ -96,14 +96,6 @@ pub const REPO_FRONTIER_PROPOSAL_MODELING_LAUNCH_BINDING_CONTRACT: &str =
pub const REPO_MODEL_CLAIM_CHALLENGE_SCHEMA_VERSION: &str =
"epiphany.eyes.repo_model_claim_challenge.v0";
pub const REPO_MODEL_CLAIM_CHALLENGE_CONTRACT: &str = "epiphany.repo_model_claim_challenge.v0";
pub const REPO_MODEL_CLAIM_REPAIR_REQUEST_SCHEMA_VERSION: &str =
"epiphany.modeling.repo_model_claim_repair_request.v0";
pub const REPO_MODEL_CLAIM_REPAIR_REQUEST_CONTRACT: &str =
"epiphany.repo_model_claim_repair_request.v0";
pub const REPO_MODEL_CLAIM_REPAIR_LAUNCH_BINDING_SCHEMA_VERSION: &str =
"epiphany.coordinator.repo_model_claim_repair_launch_binding.v0";
pub const REPO_MODEL_CLAIM_REPAIR_LAUNCH_BINDING_CONTRACT: &str =
"epiphany.repo_model_claim_repair_launch_binding.v0";
pub const REPO_FRONTIER_PLANNING_LAUNCH_BINDING_SCHEMA_VERSION: &str =
"epiphany.coordinator.repo_frontier_planning_launch_binding.v0";
pub const REPO_FRONTIER_PLANNING_LAUNCH_BINDING_CONTRACT: &str =
@ -167,90 +159,6 @@ pub struct RepoModelClaimChallenge {
pub contract: String,
}
#[derive(Debug, Clone, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.modeling.repo_model_claim_repair_request",
schema = "RepoModelClaimRepairRequest"
)]
pub struct RepoModelClaimRepairRequest {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub request_id: String,
#[cultcache(key = 2)]
pub challenge_id: String,
#[cultcache(key = 3)]
pub challenge_sha256: String,
#[cultcache(key = 4)]
pub eyes_evidence_packet_id: String,
#[cultcache(key = 5)]
pub eyes_evidence_packet_sha256: String,
#[cultcache(key = 6)]
pub source_result_id: String,
#[cultcache(key = 7)]
pub source_job_id: String,
#[cultcache(key = 8)]
pub original_model_projection_digest: String,
#[cultcache(key = 9)]
pub original_model_source_documents: Vec<crate::EpiphanyMindDocumentVersion>,
#[cultcache(key = 10)]
pub current_model_projection_digest: String,
#[cultcache(key = 11)]
pub current_model_source_documents: Vec<crate::EpiphanyMindDocumentVersion>,
#[cultcache(key = 12)]
pub target_claim_id: String,
#[cultcache(key = 13)]
pub target_claim_sha256: String,
#[cultcache(key = 14)]
pub runtime_id: String,
#[cultcache(key = 15)]
pub thread_id: String,
#[cultcache(key = 16)]
pub affected_frontier: Vec<RepoModelClaimRepairFrontierRef>,
#[cultcache(key = 17)]
pub requested_at: String,
#[cultcache(key = 18)]
pub contract: String,
}
#[derive(Debug, Clone, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.coordinator.repo_model_claim_repair_launch_binding",
schema = "RepoModelClaimRepairLaunchBinding"
)]
pub struct RepoModelClaimRepairLaunchBinding {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub binding_record_id: String,
#[cultcache(key = 2)]
pub repair_request_id: String,
#[cultcache(key = 3)]
pub challenge_id: String,
#[cultcache(key = 4)]
pub challenge_sha256: String,
#[cultcache(key = 5)]
pub job_id: String,
#[cultcache(key = 6)]
pub binding_id: String,
#[cultcache(key = 7)]
pub runtime_id: String,
#[cultcache(key = 8)]
pub thread_id: String,
#[cultcache(key = 9)]
pub launched_at: String,
#[cultcache(key = 10)]
pub worker_launch_document_sha256: String,
#[cultcache(key = 11)]
pub contract: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RepoModelClaimRepairFrontierRef {
pub frontier_item_id: String,
pub frontier_item_sha256: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RepoFrontierProposalSourceKind {

302
epiphany-core/src/runtime_spine.rs
View file

@ -70,7 +70,6 @@ use crate::repo_model_gateway::{
REPO_FRONTIER_ROUTE_CONTRACT, REPO_FRONTIER_ROUTE_SCHEMA_VERSION,
REPO_FRONTIER_WORK_PROPOSAL_CONTRACT, REPO_FRONTIER_WORK_PROPOSAL_SCHEMA_VERSION,
REPO_MODEL_CLAIM_CHALLENGE_CONTRACT, REPO_MODEL_CLAIM_CHALLENGE_SCHEMA_VERSION,
REPO_MODEL_CLAIM_REPAIR_REQUEST_CONTRACT, REPO_MODEL_CLAIM_REPAIR_REQUEST_SCHEMA_VERSION,
RUNTIME_REPOSITORY_DOMAIN_BINDING_CONTRACT, RUNTIME_REPOSITORY_DOMAIN_BINDING_KEY,
RUNTIME_REPOSITORY_DOMAIN_BINDING_SCHEMA_VERSION, RepoFrontierAutonomousProposalBinding,
RepoFrontierExecutionAmendmentReceipt, RepoFrontierHandsAuthority, RepoFrontierModelingRequest,
@ -83,8 +82,7 @@ use crate::repo_model_gateway::{
RepoFrontierProposalModelingLaunchBinding, RepoFrontierProposalModelingRequest,
RepoFrontierRelinquishmentReceipt, RepoFrontierResearchRequest, RepoFrontierRoute,
RepoFrontierVerdictDisposition, RepoFrontierWorkProposal, RepoModelClaimChallenge,
RepoModelClaimRepairFrontierRef, RepoModelClaimRepairLaunchBinding,
RepoModelClaimRepairRequest, RuntimeRepositoryDomainBinding,
RuntimeRepositoryDomainBinding,
};
use crate::runtime_store_backend::{
RuntimeSpineBackingStore as SingleFileMessagePackBackingStore, runtime_spine_backing_store,
@ -449,8 +447,6 @@ pub struct EpiphanyRuntimeWorkerLaunchRequest {
pub organ_launch_contract: EpiphanyLaunchOrganContract,
#[cultcache(key = 11, default)]
pub proposal_modeling_request_id: Option<String>,
#[cultcache(key = 12, default)]
pub claim_repair_request_id: Option<String>,
#[cultcache(key = 13, default)]
pub frontier_planning_request_id: Option<String>,
#[cultcache(key = 14, default)]
@ -635,8 +631,6 @@ pub struct EpiphanyRuntimeRoleWorkerResult {
pub repo_frontier_modeling_request_id: Option<String>,
#[cultcache(key = 24, default)]
pub proposal_modeling_request_id: Option<String>,
#[cultcache(key = 25, default)]
pub claim_repair_request_id: Option<String>,
#[cultcache(key = 26, default)]
pub frontier_planning_request_id: Option<String>,
#[cultcache(key = 27, default)]
@ -1021,7 +1015,6 @@ pub struct RuntimeSpineHeartbeatJobOptions {
pub output_contract_id: String,
pub organ_launch_contract: EpiphanyLaunchOrganContract,
pub proposal_modeling_request_id: Option<String>,
pub claim_repair_request_id: Option<String>,
pub frontier_planning_request_id: Option<String>,
pub frontier_plan_mind_request_id: Option<String>,
pub imagination_consideration_request_id: Option<String>,
@ -1078,7 +1071,6 @@ pub struct EpiphanyJobLaunchRequest {
pub organ_launch_contract: EpiphanyLaunchOrganContract,
pub max_runtime_seconds: Option<u64>,
pub proposal_modeling_request_id: Option<String>,
pub claim_repair_request_id: Option<String>,
pub frontier_planning_request_id: Option<String>,
pub frontier_plan_mind_request_id: Option<String>,
pub imagination_consideration_request_id: Option<String>,
@ -1156,8 +1148,6 @@ pub fn runtime_spine_cache(store_path: impl AsRef<Path>) -> Result<CultCache> {
cache.register_entry_type::<crate::RuntimeRepositoryBodyStoreBinding>()?;
cache.register_entry_type::<crate::RuntimeWorkspaceCoverageStoreBinding>()?;
cache.register_entry_type::<RepoModelClaimChallenge>()?;
cache.register_entry_type::<RepoModelClaimRepairRequest>()?;
cache.register_entry_type::<RepoModelClaimRepairLaunchBinding>()?;
cache.register_entry_type::<RepoFrontierRoute>()?;
cache.register_entry_type::<RepoFrontierHandsAuthority>()?;
cache.register_entry_type::<HandsActionRefusalReceipt>()?;
@ -3146,12 +3136,6 @@ pub fn open_runtime_spine_heartbeat_job(
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,
@ -3259,7 +3243,6 @@ pub fn open_runtime_spine_heartbeat_job(
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,
@ -3294,12 +3277,6 @@ pub fn prepare_runtime_spine_heartbeat_job(
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,
@ -3433,7 +3410,6 @@ pub fn prepare_runtime_spine_heartbeat_job(
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,
@ -3555,39 +3531,6 @@ fn validate_repository_body_launch_carrier(
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,
@ -4583,17 +4526,10 @@ pub fn put_runtime_role_worker_result(
"only Modeling results may carry a proposal Modeling request binding"
));
}
if result.claim_repair_request_id.is_some() && !result.role_id.eq_ignore_ascii_case("modeling")
{
return Err(anyhow!(
"only Modeling results may carry a claim repair request binding"
));
}
let is_modeling = result.role_id.eq_ignore_ascii_case("modeling");
let modeling_binding_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)
@ -4606,8 +4542,7 @@ pub fn put_runtime_role_worker_result(
if is_modeling
&& (result.repo_frontier_modeling_request_id
!= worker_launch.repo_frontier_modeling_request_id
|| result.proposal_modeling_request_id != worker_launch.proposal_modeling_request_id
|| result.claim_repair_request_id != worker_launch.claim_repair_request_id)
|| result.proposal_modeling_request_id != worker_launch.proposal_modeling_request_id)
{
return Err(anyhow!(
"Modeling result must exactly preserve its runtime-owned request authority"
@ -4628,21 +4563,7 @@ pub fn put_runtime_role_worker_result(
})?;
proposal.validate()?;
let operations = proposal.operations()?;
if worker_launch.claim_repair_request_id.is_some() {
if result.state_patch_msgpack.is_some()
|| result.self_patch_msgpack.is_some()
|| operations.iter().any(|operation| {
!matches!(
operation,
crate::EpiphanyRepoModelMutationOperation::PutNode { .. }
)
})
{
return Err(anyhow!(
"claim repair request may authorize only semantic RepoModel node mutation"
));
}
} else if (worker_launch.repo_frontier_modeling_request_id.is_some()
if (worker_launch.repo_frontier_modeling_request_id.is_some()
|| worker_launch.proposal_modeling_request_id.is_some())
&& operations.iter().any(|operation| {
!matches!(
@ -4681,7 +4602,6 @@ pub fn put_runtime_role_worker_result(
|| 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"
@ -4750,7 +4670,6 @@ pub fn put_runtime_role_worker_result(
|| 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!(
@ -4852,7 +4771,6 @@ pub fn put_runtime_role_worker_result(
|| 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()
@ -4941,7 +4859,6 @@ pub fn put_runtime_role_worker_result(
|| 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"
@ -6900,219 +6817,6 @@ pub fn commit_repo_model_claim_challenge(
Ok(())
}
pub fn commit_repo_model_claim_repair_request(
store_path: impl AsRef<Path>,
challenge_id: &str,
requested_at: &str,
) -> Result<RepoModelClaimRepairRequest> {
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 (view, basis) = current_keyed_repo_model(&cache)?;
let model = view.memory_context_projection();
let challenge = cache
.get::<RepoModelClaimChallenge>(challenge_id)?
.ok_or_else(|| anyhow!("claim repair request requires exact challenge"))?;
validate_repo_model_claim_challenge_chain(&cache, &model, &basis, &challenge, true)?;
let packet = cache
.get::<EyesEvidencePacket>(&challenge.eyes_evidence_packet_id)?
.ok_or_else(|| anyhow!("claim repair request requires exact Eyes packet"))?;
let identity = cache
.get::<EpiphanyRuntimeIdentity>(RUNTIME_IDENTITY_KEY)?
.ok_or_else(|| anyhow!("claim repair request requires runtime identity"))?;
let thread = cache
.get::<crate::EpiphanyThreadStateEntry>(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 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::<Result<Vec<_>>>()?;
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_model_projection_digest: challenge.model_projection_digest.clone(),
original_model_source_documents: challenge.model_source_documents.clone(),
current_model_projection_digest: basis.projection_digest.clone(),
current_model_source_documents: basis.source_documents.clone(),
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::<RepoModelClaimRepairRequest>(&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 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 = keyed_repo_model_basis_envelopes(&cache, &basis)?;
expected.extend([
challenge_envelope.clone(),
packet_envelope.clone(),
identity_envelope.clone(),
thread_envelope.clone(),
]);
let mut replacement = expected.clone();
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::<RepoModelClaimRepairRequest>(&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 view = require_keyed_repo_model_basis(
cache,
&request.current_model_projection_digest,
&request.current_model_source_documents,
)?;
let model = view.memory_context_projection();
let basis = view.reasoning_basis();
let challenge = cache
.get::<RepoModelClaimChallenge>(&request.challenge_id)?
.ok_or_else(|| anyhow!("claim repair request requires exact challenge"))?;
validate_repo_model_claim_challenge_chain(cache, &model, &basis, &challenge, true)?;
let packet = cache
.get::<EyesEvidencePacket>(&challenge.eyes_evidence_packet_id)?
.ok_or_else(|| anyhow!("claim repair request requires exact Eyes packet"))?;
let identity = cache
.get::<EpiphanyRuntimeIdentity>(RUNTIME_IDENTITY_KEY)?
.ok_or_else(|| anyhow!("claim repair request requires runtime identity"))?;
let thread = cache
.get::<crate::EpiphanyThreadStateEntry>(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 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::<Result<Vec<_>>>()?;
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_model_projection_digest: challenge.model_projection_digest.clone(),
original_model_source_documents: challenge.model_source_documents.clone(),
current_model_projection_digest: basis.projection_digest,
current_model_source_documents: basis.source_documents,
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,

2
epiphany-core/src/substrate_gate.rs
View file

@ -297,7 +297,6 @@ mod tests {
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -326,7 +325,6 @@ mod tests {
),
max_runtime_seconds: None,
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,

3
epiphany-core/src/surfaces/mod.rs
View file

@ -133,12 +133,9 @@ pub use worker_launch::REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_CONTRACT;
pub use worker_launch::REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_SCHEMA_VERSION;
pub use worker_launch::REPO_FRONTIER_RESEARCH_CONTEXT_CONTRACT;
pub use worker_launch::REPO_FRONTIER_RESEARCH_CONTEXT_SCHEMA_VERSION;
pub use worker_launch::REPO_MODEL_CLAIM_REPAIR_CONTEXT_CONTRACT;
pub use worker_launch::REPO_MODEL_CLAIM_REPAIR_CONTEXT_SCHEMA_VERSION;
pub use worker_launch::ROLE_WORKER_OUTPUT_CONTRACT_ID;
pub use worker_launch::RepoFrontierPlanMindContextProjection;
pub use worker_launch::RepoFrontierPlanningContextProjection;
pub use worker_launch::RepoFrontierProposalModelingContextProjection;
pub use worker_launch::RepoFrontierResearchContextProjection;
pub use worker_launch::RepoModelClaimRepairContextProjection;
pub use worker_launch::build_reorient_job_launch_request;

57
epiphany-core/src/surfaces/worker_launch.rs
View file

@ -30,10 +30,6 @@ pub const REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_SCHEMA_VERSION: &str =
"epiphany.worker.repo_frontier_proposal_modeling_context.v1";
pub const REPO_FRONTIER_PROPOSAL_MODELING_CONTEXT_CONTRACT: &str =
"epiphany.repo_frontier_proposal_modeling_context.v1";
pub const REPO_MODEL_CLAIM_REPAIR_CONTEXT_SCHEMA_VERSION: &str =
"epiphany.worker.repo_model_claim_repair_context.v1";
pub const REPO_MODEL_CLAIM_REPAIR_CONTEXT_CONTRACT: &str =
"epiphany.repo_model_claim_repair_context.v1";
pub const REPO_FRONTIER_PLANNING_CONTEXT_SCHEMA_VERSION: &str =
"epiphany.worker.repo_frontier_planning_context.v1";
pub const REPO_FRONTIER_PLANNING_CONTEXT_CONTRACT: &str =
@ -109,8 +105,6 @@ pub struct EpiphanyRoleWorkerLaunchDocument {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub proposal_modeling_context: Option<RepoFrontierProposalModelingContextProjection>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub claim_repair_context: Option<RepoModelClaimRepairContextProjection>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub frontier_planning_context: Option<RepoFrontierPlanningContextProjection>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub frontier_research_context: Option<RepoFrontierResearchContextProjection>,
@ -272,56 +266,6 @@ pub struct RepoFrontierProposalModelingContextProjection {
pub model_source_documents: Vec<crate::EpiphanyMindDocumentVersion>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RepoModelClaimRepairContextProjection {
pub schema_version: String,
pub contract: String,
pub request_id: String,
pub challenge_id: String,
pub challenge_sha256: String,
pub eyes_evidence_packet_id: String,
pub eyes_evidence_packet_sha256: String,
pub source_result_id: String,
pub source_job_id: String,
pub original_model_projection_digest: String,
pub original_model_source_documents: Vec<crate::EpiphanyMindDocumentVersion>,
pub current_model_projection_digest: String,
pub current_model_source_documents: Vec<crate::EpiphanyMindDocumentVersion>,
pub target_claim_id: String,
pub target_claim_sha256: String,
pub runtime_id: String,
pub thread_id: String,
pub affected_frontier: Vec<crate::RepoModelClaimRepairFrontierRef>,
pub requested_at: String,
}
impl RepoModelClaimRepairContextProjection {
pub(crate) fn from_request(request: &crate::RepoModelClaimRepairRequest) -> Self {
Self {
schema_version: REPO_MODEL_CLAIM_REPAIR_CONTEXT_SCHEMA_VERSION.into(),
contract: REPO_MODEL_CLAIM_REPAIR_CONTEXT_CONTRACT.into(),
request_id: request.request_id.clone(),
challenge_id: request.challenge_id.clone(),
challenge_sha256: request.challenge_sha256.clone(),
eyes_evidence_packet_id: request.eyes_evidence_packet_id.clone(),
eyes_evidence_packet_sha256: request.eyes_evidence_packet_sha256.clone(),
source_result_id: request.source_result_id.clone(),
source_job_id: request.source_job_id.clone(),
original_model_projection_digest: request.original_model_projection_digest.clone(),
original_model_source_documents: request.original_model_source_documents.clone(),
current_model_projection_digest: request.current_model_projection_digest.clone(),
current_model_source_documents: request.current_model_source_documents.clone(),
target_claim_id: request.target_claim_id.clone(),
target_claim_sha256: request.target_claim_sha256.clone(),
runtime_id: request.runtime_id.clone(),
thread_id: request.thread_id.clone(),
affected_frontier: request.affected_frontier.clone(),
requested_at: request.requested_at.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RepoFrontierPlanningContextProjection {
@ -472,7 +416,6 @@ pub fn build_reorient_job_launch_request(
organ_launch_contract,
max_runtime_seconds: input.max_runtime_seconds,
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,

49
epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs
View file

@ -34,8 +34,8 @@ use epiphany_openai_runtime::complete_worker_job_from_assistant_text;
use epiphany_openai_runtime::default_codex_home;
use epiphany_openai_runtime::default_options;
use epiphany_openai_runtime::ensure_openai_runtime_ready;
use epiphany_openai_runtime::fail_worker_job;
use epiphany_openai_runtime::fail_model_backed_worker_job;
use epiphany_openai_runtime::fail_worker_job;
use epiphany_openai_runtime::failed_frontier_planning_role_result;
use epiphany_openai_runtime::load_worker_launch_request;
use epiphany_openai_runtime::record_openai_events;
@ -166,14 +166,12 @@ async fn main() -> Result<()> {
)
.await
{
Ok(result) => {
seal_worker_runtime_result(
&timeout_store,
&timeout_job_id,
result,
&pass_progress,
)?
}
Ok(result) => seal_worker_runtime_result(
&timeout_store,
&timeout_job_id,
result,
&pass_progress,
)?,
Err(_) => {
let summary = format!("Worker runtime timed out after {seconds} seconds.");
let result = fail_worker_and_openai_jobs(
@ -782,8 +780,10 @@ struct WorkerPassProgress(Arc<Mutex<Option<String>>>);
impl WorkerPassProgress {
fn note_model_request(&self, request_id: &str) {
*self.0.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) =
Some(request_id.to_string());
*self
.0
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(request_id.to_string());
}
fn terminal_request_id(&self) -> Option<String> {
@ -856,9 +856,7 @@ fn fail_worker_and_openai_jobs(
fn persisted_model_request_exists(store_path: &Path, request_id: &str) -> Result<bool> {
let mut cache = epiphany_core::runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
Ok(cache
.get::<EpiphanyModelRequest>(request_id)?
.is_some())
Ok(cache.get::<EpiphanyModelRequest>(request_id)?.is_some())
}
fn fail_worker_for_runtime_error(
@ -939,12 +937,8 @@ async fn run_worker_launch_with_tool_continuation(
let launch_request = load_worker_launch_request(&options.store_path, &options.job_id)?;
let basis = epiphany_core::worker_reasoning_basis(&options.store_path, &launch_request)?;
epiphany_core::put_reasoning_basis(&options.store_path, &basis)?;
let mut initial_request = build_worker_model_request(
&launch_request,
&options.provider,
&options.model,
&basis,
)?;
let mut initial_request =
build_worker_model_request(&launch_request, &options.provider, &options.model, &basis)?;
let requested_public_source_intents =
if launch_request.repo_frontier_research_request_id.is_some() {
epiphany_core::put_runtime_requested_public_source_intents(
@ -1559,7 +1553,6 @@ mod tests {
organ_launch_contract: launch.organ_launch_contract.clone(),
max_runtime_seconds: None,
proposal_modeling_request_id: launch.proposal_modeling_request_id.clone(),
claim_repair_request_id: launch.claim_repair_request_id.clone(),
frontier_planning_request_id: launch.frontier_planning_request_id.clone(),
frontier_plan_mind_request_id: launch.frontier_plan_mind_request_id.clone(),
imagination_consideration_request_id: launch
@ -1608,7 +1601,6 @@ mod tests {
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -1636,7 +1628,6 @@ mod tests {
epiphany_core::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,
@ -1721,7 +1712,6 @@ mod tests {
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -1749,7 +1739,6 @@ mod tests {
epiphany_core::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,
@ -1761,11 +1750,9 @@ mod tests {
},
)?;
let launch = epiphany_core::runtime_worker_launch_request(
&store,
"worker-job-runtime-error",
)?
.expect("worker launch");
let launch =
epiphany_core::runtime_worker_launch_request(&store, "worker-job-runtime-error")?
.expect("worker launch");
let basis = epiphany_core::worker_reasoning_basis(&store, &launch)?;
epiphany_core::put_reasoning_basis(&store, &basis)?;
let mut request = EpiphanyModelRequest::new(
@ -1860,7 +1847,6 @@ mod tests {
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -1888,7 +1874,6 @@ mod tests {
epiphany_core::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,

24
epiphany-openai-runtime/src/lib.rs
View file

@ -344,12 +344,8 @@ where
}
let basis = epiphany_core::worker_reasoning_basis(&options.store_path, &launch_request)?;
epiphany_core::put_reasoning_basis(&options.store_path, &basis)?;
let model_request = build_worker_model_request(
&launch_request,
&options.provider,
&options.model,
&basis,
)?;
let model_request =
build_worker_model_request(&launch_request, &options.provider, &options.model, &basis)?;
let openai_options = EpiphanyOpenAiRuntimeOptions {
store_path: options.store_path.clone(),
codex_home: options.codex_home,
@ -2232,7 +2228,6 @@ fn role_worker_result_from_ingress(
frontier_route_id: clean_optional_string(result.frontier_route_id.as_deref()),
repo_frontier_modeling_request_id: launch_request.repo_frontier_modeling_request_id.clone(),
proposal_modeling_request_id: launch_request.proposal_modeling_request_id.clone(),
claim_repair_request_id: launch_request.claim_repair_request_id.clone(),
frontier_planning_request_id: launch_request.frontier_planning_request_id.clone(),
frontier_plan_candidate_msgpack,
frontier_plan_mind_request_id: frontier_plan_mind_context
@ -2296,7 +2291,6 @@ pub fn failed_frontier_planning_role_result(
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,
@ -2734,7 +2728,6 @@ mod tests {
epiphany_core::ROLE_WORKER_OUTPUT_CONTRACT_ID,
),
proposal_modeling_request_id: Some("proposal-request-1".into()),
claim_repair_request_id: None,
frontier_planning_request_id: None,
frontier_plan_mind_request_id: None,
imagination_consideration_request_id: None,
@ -2883,7 +2876,6 @@ mod tests {
epiphany_core::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,
@ -3010,7 +3002,6 @@ mod tests {
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: Some(context),
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -3047,7 +3038,6 @@ mod tests {
epiphany_core::ROLE_WORKER_OUTPUT_CONTRACT_ID,
),
proposal_modeling_request_id: Some("proposal-request-1".into()),
claim_repair_request_id: None,
frontier_planning_request_id: None,
frontier_plan_mind_request_id: None,
imagination_consideration_request_id: None,
@ -3107,7 +3097,6 @@ mod tests {
epiphany_core::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,
@ -3184,7 +3173,6 @@ mod tests {
epiphany_core::ROLE_WORKER_OUTPUT_CONTRACT_ID,
),
proposal_modeling_request_id: None,
claim_repair_request_id: None,
frontier_planning_request_id: Some("planning-request-1".into()),
frontier_plan_mind_request_id: None,
imagination_consideration_request_id: None,
@ -3355,7 +3343,6 @@ mod tests {
epiphany_core::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: Some(request.request_id.clone()),
@ -3428,7 +3415,6 @@ mod tests {
dynamic_prompt_context: None,
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -3465,7 +3451,6 @@ mod tests {
epiphany_core::ROLE_WORKER_OUTPUT_CONTRACT_ID,
),
proposal_modeling_request_id: None,
claim_repair_request_id: None,
frontier_planning_request_id: Some("planning-request-1".into()),
frontier_plan_mind_request_id: None,
imagination_consideration_request_id: None,
@ -3508,7 +3493,6 @@ mod tests {
epiphany_core::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: Some("mind-request-1".into()),
imagination_consideration_request_id: None,
@ -3792,7 +3776,6 @@ mod tests {
),
repository_body_observation_basis: Some(body_basis.clone()),
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -3820,7 +3803,6 @@ mod tests {
epiphany_core::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,
@ -4109,7 +4091,6 @@ mod tests {
),
repository_body_observation_basis: None,
proposal_modeling_context: None,
claim_repair_context: None,
frontier_planning_context: None,
frontier_research_context: None,
frontier_plan_mind_context: None,
@ -4137,7 +4118,6 @@ mod tests {
epiphany_core::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,