diff --git a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs index 3963b15a..1e7720e1 100644 --- a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs +++ b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs @@ -70,8 +70,8 @@ use epiphany_core::{ write_workspace_coverage_process_termination_observation, }; use epiphany_core::{ - authenticate_current_workspace_coverage_advancement, - authenticate_current_workspace_coverage_terminal_authority, + authenticate_current_workspace_coverage_advancement_sight, + authenticate_current_workspace_coverage_terminal_sight, }; use epiphany_core::{ epiphany_packaged_release_binary_path, epiphany_packaged_release_witness_sha256, @@ -898,7 +898,21 @@ fn publish_managed_service_iteration_health( continue; } }; - match authenticate_current_workspace_coverage_terminal_authority(runtime_store) { + let host = match open_default_host_identity() { + Ok(host) => host, + Err(error) => { + contradictions.push(format!( + "workspace health cannot authenticate host: {error:#}" + )); + continue; + } + }; + match authenticate_current_workspace_coverage_terminal_sight( + runtime_store, + &args.store, + &args.runtime_id, + host.entry(), + ) { Ok(Some(authority)) => { terminal_current += 1; workspace_evidence = Some(format!( @@ -910,15 +924,6 @@ fn publish_managed_service_iteration_health( )); } Ok(None) => { - let host = match open_default_host_identity() { - Ok(host) => host, - Err(error) => { - contradictions.push(format!( - "workspace health cannot authenticate host: {error:#}" - )); - continue; - } - }; let launch = match load_latest_workspace_coverage_managed_process_launch( &args.store, args.runtime_id.clone(), @@ -932,26 +937,30 @@ fn publish_managed_service_iteration_health( continue; } }; - match authenticate_current_workspace_coverage_advancement( + match authenticate_current_workspace_coverage_advancement_sight( runtime_store, &args.store, &args.runtime_id, &launch.launch_id, host.entry(), - Utc::now(), - Duration::seconds(WORKSPACE_PROGRESS_NO_ADVANCE_LEASE_SECONDS), ) { Ok(Some(authority)) => { - warming += 1; - workspace_evidence = Some(format!( - "workspaceProgressId={} workspaceCheckpointId={} workspacePlanId={} workspaceCompletedUnits={} workspaceTotalUnits={} workspaceLastAdvancedAt={}", - authority.progress_id, - authority.checkpoint_id, - authority.plan_id, - authority.completed_units, - authority.total_units, - authority.last_advanced_at_utc - )); + let advanced = + DateTime::parse_from_rfc3339(&authority.last_advanced_at_utc) + .map(|time| time.with_timezone(&Utc)); + match advanced { + Ok(advanced) if Utc::now().signed_duration_since(advanced) >= Duration::zero() + && Utc::now().signed_duration_since(advanced) <= Duration::seconds(WORKSPACE_PROGRESS_NO_ADVANCE_LEASE_SECONDS) => { + warming += 1; + workspace_evidence = Some(format!( + "workspaceProgressId={} workspaceCheckpointId={} workspacePlanId={} workspaceCompletedUnits={} workspaceTotalUnits={} workspaceLastAdvancedAt={}", + authority.progress_id, authority.checkpoint_id, authority.plan_id, + authority.completed_units, authority.total_units, authority.last_advanced_at_utc + )); + } + Ok(_) => contradictions.push("workspace advancement sight exceeded the supervisor no-advance lease".into()), + Err(error) => contradictions.push(format!("workspace advancement sight time is invalid: {error:#}")), + } } Ok(None) => {} Err(error) => contradictions.push(format!( @@ -4032,6 +4041,30 @@ mod semantic_projector_authority_tests { assert!(source.contains("WindowsIdentity]::GetCurrent().User.Value")); } + #[test] + fn workspace_health_reads_signed_sight_and_never_opens_owned_coverage_store() { + let source = include_str!("epiphany-daemon-supervisor.rs"); + let start = source + .find("fn publish_managed_service_iteration_health") + .unwrap(); + let tail = &source[start..]; + let end = tail.find("\nfn ").unwrap(); + let body = &tail[..end]; + let terminal = body + .find("authenticate_current_workspace_coverage_terminal_sight") + .unwrap(); + let advancement = body + .find("authenticate_current_workspace_coverage_advancement_sight") + .unwrap(); + assert!( + terminal < advancement, + "terminal sight must be preferred before warming sight" + ); + assert!(!body.contains("open_workspace_coverage_authority")); + assert!(!body.contains("authenticate_current_workspace_coverage_terminal_authority")); + assert!(!body.contains("authenticate_current_workspace_coverage_advancement(")); + } + #[test] fn windows_argv_quoting_preserves_paths_and_escapes_parser_boundaries() { assert_eq!( diff --git a/epiphany-core/src/bin/epiphany-repository-body.rs b/epiphany-core/src/bin/epiphany-repository-body.rs index 003a68ea..12891919 100644 --- a/epiphany-core/src/bin/epiphany-repository-body.rs +++ b/epiphany-core/src/bin/epiphany-repository-body.rs @@ -5,8 +5,9 @@ use epiphany_core::{ EpiphanyMemoryLifecycle, EpiphanyMemoryNode, EpiphanyMemoryNodeKind, EpiphanyMemoryProfile, MEMORY_GRAPH_SCHEMA_VERSION, ObserveOutcome, RuntimeSpineInitOptions, admit_legacy_agent_memory_generation, bind_repository_body, bind_runtime_to_agent_memory_swarm, - ensure_agent_memory_swarm_identity, ensure_runtime_repo_model, initialize_runtime_spine, - load_repository_body_status, observe_repository_body, + bind_runtime_workspace_coverage_store, ensure_agent_memory_swarm_identity, + ensure_runtime_repo_model, initialize_runtime_spine, load_repository_body_status, + observe_repository_body, }; use std::path::PathBuf; @@ -21,6 +22,8 @@ fn main() -> Result<()> { let store = PathBuf::from(required(&args, "--store")?); let runtime_store = PathBuf::from(required(&args, "--runtime-store")?); let agent_store = PathBuf::from(required(&args, "--agent-store")?); + let workspace_coverage_store = + PathBuf::from(required(&args, "--workspace-coverage-store")?); let workspace_id = required(&args, "--workspace-id")?; let runtime_id = required(&args, "--runtime-id")?; let swarm_id = required(&args, "--swarm-id")?; @@ -37,6 +40,7 @@ fn main() -> Result<()> { admit_legacy_agent_memory_generation(&agent_store)?; bind_runtime_to_agent_memory_swarm(&runtime_store, &agent_store, &at)?; let binding = bind_repository_body(&repo, &store, &runtime_store, workspace_id)?; + bind_runtime_workspace_coverage_store(&runtime_store, &workspace_coverage_store, &at)?; observe_repository_body(&repo, &store, &runtime_store)?; let bootstrap = EpiphanyMemoryGraphSnapshot { schema_version: Some(MEMORY_GRAPH_SCHEMA_VERSION.to_string()), @@ -163,7 +167,7 @@ fn required<'a>(args: &'a [String], name: &str) -> Result<&'a str> { } fn usage() -> Result { bail!( - "usage: epiphany-repository-body bootstrap --repo PATH --store PATH --runtime-store PATH --agent-store PATH --workspace-id ID --runtime-id ID --swarm-id ID | bind --repo PATH --store PATH --runtime-store PATH --workspace-id ID | observe --repo PATH --store PATH --runtime-store PATH | status --store PATH | smoke" + "usage: epiphany-repository-body bootstrap --repo PATH --store PATH --runtime-store PATH --agent-store PATH --workspace-coverage-store PATH --workspace-id ID --runtime-id ID --swarm-id ID | bind --repo PATH --store PATH --runtime-store PATH --workspace-id ID | observe --repo PATH --store PATH --runtime-store PATH | status --store PATH | smoke" ) } fn smoke() -> Result<()> { @@ -174,6 +178,7 @@ fn smoke() -> Result<()> { )); let runtime_store = store.with_extension("runtime.cc"); let agent_store = store.with_extension("agents.cc"); + let workspace_coverage_store = store.with_extension("workspace-coverage.cc"); initialize_runtime_spine( &runtime_store, RuntimeSpineInitOptions { @@ -190,12 +195,19 @@ fn smoke() -> Result<()> { &runtime_store, "epiphany-repository-body-smoke", )?; + bind_runtime_workspace_coverage_store( + &runtime_store, + &workspace_coverage_store, + "2026-07-15T00:00:02Z", + )?; let outcome = observe_repository_body(&root, &store, &runtime_store)?; let observed = load_repository_body_status(&store)? .ok_or_else(|| anyhow::anyhow!("smoke observation missing after commit"))?; std::fs::remove_file(&store)?; std::fs::remove_file(&runtime_store)?; std::fs::remove_file(&agent_store)?; + std::fs::remove_file(&workspace_coverage_store)?; + let _ = std::fs::remove_file(workspace_coverage_store.with_extension("cc.lock")); let generation = match outcome { ObserveOutcome::Created(value) | ObserveOutcome::Unchanged(value) => value.generation, }; diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index a0d6b847..b94bce0b 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -7,12 +7,15 @@ use crate::default_soul_cultnet_contracts; use crate::default_substrate_gate_cultnet_contracts; use crate::packaged_release::{EpiphanyPackagedReleaseEntry, EpiphanyPackagedReleaseHead}; use crate::workspace_coverage_process_documents::{ + WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION, WORKSPACE_COVERAGE_PROCESS_EVIDENCE_HEAD_SCHEMA_VERSION, WORKSPACE_COVERAGE_PROCESS_LAUNCH_SCHEMA_VERSION, WORKSPACE_COVERAGE_PROCESS_TERMINATION_SCHEMA_VERSION, WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_SCHEMA_VERSION, + WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION, WorkspaceCoverageAdvancementSightEntry, WorkspaceCoverageManagedProcessLaunchEntry, WorkspaceCoverageProcessEvidenceHead, WorkspaceCoverageProcessTerminationObservationEntry, WorkspaceCoverageProviderHeartbeatEntry, + WorkspaceCoverageTerminalSightEntry, }; use crate::workspace_coverage_projection_progress::{ WORKSPACE_COVERAGE_PROJECTION_PROGRESS_SCHEMA_VERSION, WorkspaceCoverageProjectionProgressEntry, @@ -2661,6 +2664,8 @@ cultmesh_documents!(EpiphanyCultMeshDocuments { WorkspaceCoverageProviderHeartbeatEntry => WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_SCHEMA_VERSION, WorkspaceCoverageProcessTerminationObservationEntry => WORKSPACE_COVERAGE_PROCESS_TERMINATION_SCHEMA_VERSION, WorkspaceCoverageProjectionProgressEntry => WORKSPACE_COVERAGE_PROJECTION_PROGRESS_SCHEMA_VERSION, + WorkspaceCoverageAdvancementSightEntry => WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION, + WorkspaceCoverageTerminalSightEntry => WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION, EpiphanyPackagedReleaseEntry => crate::packaged_release::EPIPHANY_PACKAGED_RELEASE_SCHEMA_VERSION, EpiphanyPackagedReleaseHead => crate::packaged_release::EPIPHANY_PACKAGED_RELEASE_HEAD_SCHEMA_VERSION, EpiphanyCultMeshIdunnDeploymentReceiptEntry => EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_SCHEMA_VERSION, diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 6f379a37..c0980255 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -1196,12 +1196,17 @@ pub use workspace_coverage_process_bootstrap::{ write_workspace_coverage_process_bootstrap, }; pub use workspace_coverage_process_documents::{ + WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION, WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_TYPE, WORKSPACE_COVERAGE_PROCESS_LAUNCH_LATEST_KEY, WORKSPACE_COVERAGE_PROCESS_LAUNCH_SCHEMA_VERSION, WORKSPACE_COVERAGE_PROCESS_LAUNCH_TYPE, WORKSPACE_COVERAGE_PROCESS_TERMINATION_SCHEMA_VERSION, WORKSPACE_COVERAGE_PROCESS_TERMINATION_TYPE, WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_LATEST_KEY, WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_SCHEMA_VERSION, - WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_TYPE, WorkspaceCoverageManagedProcessLaunchEntry, + WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_TYPE, WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION, + WORKSPACE_COVERAGE_TERMINAL_SIGHT_TYPE, WorkspaceCoverageAdvancementSightEntry, + WorkspaceCoverageManagedProcessLaunchEntry, WorkspaceCoverageProcessTerminationObservationEntry, WorkspaceCoverageProviderHeartbeatEntry, + WorkspaceCoverageTerminalSightEntry, authenticate_current_workspace_coverage_advancement_sight, + authenticate_current_workspace_coverage_terminal_sight, authenticate_workspace_coverage_managed_process_launch, authenticate_workspace_coverage_process_termination_observation, authenticate_workspace_coverage_provider_heartbeat, diff --git a/epiphany-core/src/workspace_coverage_process_documents.rs b/epiphany-core/src/workspace_coverage_process_documents.rs index 9a418cfa..376e8d24 100644 --- a/epiphany-core/src/workspace_coverage_process_documents.rs +++ b/epiphany-core/src/workspace_coverage_process_documents.rs @@ -42,6 +42,149 @@ const PROVIDER_HEARTBEAT_DOMAIN: &[u8] = const HOST_TERMINATION_PURPOSE: &str = "epiphany.workspace-coverage.process-termination-observation.v0"; const WORKSPACE_COVERAGE_TERMINATION_OBSERVER: &str = "epiphany-daemon-supervisor"; +const COVERAGE_ADVANCEMENT_SIGHT_DOMAIN: &[u8] = + b"epiphany.workspace-coverage.advancement-sight.signature.v0\0"; +const COVERAGE_TERMINAL_SIGHT_DOMAIN: &[u8] = + b"epiphany.workspace-coverage.terminal-sight.signature.v0\0"; + +pub const WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_TYPE: &str = + "epiphany.workspace_coverage.advancement_sight"; +pub const WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION: &str = + "epiphany.workspace_coverage.advancement_sight.v0"; +pub const WORKSPACE_COVERAGE_TERMINAL_SIGHT_TYPE: &str = + "epiphany.workspace_coverage.terminal_sight"; +pub const WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION: &str = + "epiphany.workspace_coverage.terminal_sight.v0"; + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "epiphany.workspace_coverage.advancement_sight", + schema = "WorkspaceCoverageAdvancementSightEntry" +)] +pub struct WorkspaceCoverageAdvancementSightEntry { + #[cultcache(key = 0)] + pub schema_version: String, + #[cultcache(key = 1)] + pub runtime_id: String, + #[cultcache(key = 2)] + pub workspace_id: String, + #[cultcache(key = 3)] + pub launch_id: String, + #[cultcache(key = 4)] + pub launch_envelope_digest: String, + #[cultcache(key = 5)] + pub provider_incarnation_id: String, + #[cultcache(key = 6)] + pub provider_public_key: Vec, + #[cultcache(key = 7)] + pub coverage_store_binding_id: String, + #[cultcache(key = 8)] + pub coverage_store_binding_envelope_digest: String, + #[cultcache(key = 9)] + pub coverage_store_file_identity: String, + #[cultcache(key = 10)] + pub runtime_coverage_route_envelope_digest: String, + #[cultcache(key = 11)] + pub body_binding_sha256: String, + #[cultcache(key = 12)] + pub body_observation_id: String, + #[cultcache(key = 13)] + pub body_generation: u64, + #[cultcache(key = 14)] + pub manifest_root_sha256: String, + #[cultcache(key = 15)] + pub claim_id: String, + #[cultcache(key = 16)] + pub claim_epoch: u64, + #[cultcache(key = 17)] + pub plan_id: String, + #[cultcache(key = 18)] + pub progress_id: String, + #[cultcache(key = 19)] + pub progress_envelope_digest: String, + #[cultcache(key = 20)] + pub checkpoint_id: String, + #[cultcache(key = 21)] + pub checkpoint_envelope_digest: String, + #[cultcache(key = 22)] + pub sequence: u64, + #[cultcache(key = 23)] + pub status: String, + #[cultcache(key = 24)] + pub completed_units: u64, + #[cultcache(key = 25)] + pub total_units: u64, + #[cultcache(key = 26)] + pub last_advanced_at_utc: String, + #[cultcache(key = 27)] + pub observed_at_utc: String, + #[cultcache(key = 28)] + pub provider_signature: Vec, + #[cultcache(key = 29)] + pub signature_algorithm: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "epiphany.workspace_coverage.terminal_sight", + schema = "WorkspaceCoverageTerminalSightEntry" +)] +pub struct WorkspaceCoverageTerminalSightEntry { + #[cultcache(key = 0)] + pub schema_version: String, + #[cultcache(key = 1)] + pub runtime_id: String, + #[cultcache(key = 2)] + pub workspace_id: String, + #[cultcache(key = 3)] + pub launch_id: String, + #[cultcache(key = 4)] + pub launch_envelope_digest: String, + #[cultcache(key = 5)] + pub provider_incarnation_id: String, + #[cultcache(key = 6)] + pub provider_public_key: Vec, + #[cultcache(key = 7)] + pub coverage_store_binding_id: String, + #[cultcache(key = 8)] + pub coverage_store_binding_envelope_digest: String, + #[cultcache(key = 9)] + pub coverage_store_file_identity: String, + #[cultcache(key = 10)] + pub runtime_coverage_route_envelope_digest: String, + #[cultcache(key = 11)] + pub body_binding_sha256: String, + #[cultcache(key = 12)] + pub body_observation_id: String, + #[cultcache(key = 13)] + pub body_generation: u64, + #[cultcache(key = 14)] + pub manifest_root_sha256: String, + #[cultcache(key = 15)] + pub claim_id: String, + #[cultcache(key = 16)] + pub claim_epoch: u64, + #[cultcache(key = 17)] + pub plan_id: String, + #[cultcache(key = 18)] + pub receipt_id: String, + #[cultcache(key = 19)] + pub receipt_envelope_digest: String, + #[cultcache(key = 20)] + pub head_id: String, + #[cultcache(key = 21)] + pub head_envelope_digest: String, + #[cultcache(key = 22)] + pub sequence: u64, + #[cultcache(key = 23)] + pub status: String, + #[cultcache(key = 24)] + pub observed_at_utc: String, + #[cultcache(key = 25)] + pub provider_signature: Vec, + #[cultcache(key = 26)] + pub signature_algorithm: String, +} #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] #[cultcache( @@ -1523,6 +1666,784 @@ fn require_nonempty(name: &str, value: &str) -> Result<()> { } Ok(()) } + +fn advancement_sight_key(launch_id: &str, claim_id: &str) -> String { + format!("epiphany-local/workspace-coverage/advancement-sight/{launch_id}/{claim_id}") +} + +fn terminal_sight_key(runtime_id: &str, body_generation: u64, body_observation_id: &str) -> String { + format!( + "epiphany-local/workspace-coverage/terminal-sight/{runtime_id}/{body_generation}/{body_observation_id}" + ) +} + +fn signed_sight_statement(domain: &[u8], unsigned: &T) -> Result> { + let mut statement = domain.to_vec(); + statement.extend(rmp_serde::to_vec_named(unsigned)?); + Ok(statement) +} + +pub(crate) fn sign_workspace_coverage_advancement_sight( + entry: &mut WorkspaceCoverageAdvancementSightEntry, + provider: &SigningKey, +) -> Result<()> { + entry.provider_signature.clear(); + validate_advancement_sight_shape(entry, false)?; + entry.provider_signature = provider + .sign(&signed_sight_statement( + COVERAGE_ADVANCEMENT_SIGHT_DOMAIN, + entry, + )?) + .to_bytes() + .to_vec(); + Ok(()) +} + +pub(crate) fn sign_workspace_coverage_terminal_sight( + entry: &mut WorkspaceCoverageTerminalSightEntry, + provider: &SigningKey, +) -> Result<()> { + entry.provider_signature.clear(); + validate_terminal_sight_shape(entry, false)?; + entry.provider_signature = provider + .sign(&signed_sight_statement( + COVERAGE_TERMINAL_SIGHT_DOMAIN, + entry, + )?) + .to_bytes() + .to_vec(); + Ok(()) +} + +pub(crate) fn write_workspace_coverage_advancement_sight( + local_verse_store: impl AsRef, + runtime_id: &str, + entry: WorkspaceCoverageAdvancementSightEntry, +) -> Result { + validate_advancement_sight_shape(&entry, true)?; + if entry.runtime_id != runtime_id { + bail!("workspace coverage advancement sight runtime argument disagrees"); + } + let backing = SingleFileMessagePackBackingStore::new(local_verse_store.as_ref()); + let node = open_epiphany_cultmesh_node(local_verse_store.as_ref(), runtime_id.to_string())?; + let key = advancement_sight_key(&entry.launch_id, &entry.claim_id); + let opening = backing.pull_all()?; + if let Some(prior) = opening.iter().find(|envelope| { + envelope.r#type == WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_TYPE && envelope.key == key + }) { + let prior: WorkspaceCoverageAdvancementSightEntry = rmp_serde::from_slice(&prior.payload)?; + validate_advancement_sight_shape(&prior, true)?; + let mut unsigned = prior.clone(); + unsigned.provider_signature.clear(); + verify_sight_signature( + COVERAGE_ADVANCEMENT_SIGHT_DOMAIN, + &unsigned, + &prior.provider_public_key, + &prior.provider_signature, + )?; + if entry.sequence <= prior.sequence + || entry.completed_units < prior.completed_units + || entry.total_units != prior.total_units + || entry.body_observation_id != prior.body_observation_id + || entry.body_generation != prior.body_generation + || entry.plan_id != prior.plan_id + || entry.launch_envelope_digest != prior.launch_envelope_digest + || entry.provider_incarnation_id != prior.provider_incarnation_id + || entry.provider_public_key != prior.provider_public_key + || entry.coverage_store_binding_id != prior.coverage_store_binding_id + || entry.coverage_store_binding_envelope_digest + != prior.coverage_store_binding_envelope_digest + || entry.coverage_store_file_identity != prior.coverage_store_file_identity + || entry.runtime_coverage_route_envelope_digest + != prior.runtime_coverage_route_envelope_digest + || entry.body_binding_sha256 != prior.body_binding_sha256 + || entry.manifest_root_sha256 != prior.manifest_root_sha256 + { + bail!("workspace coverage advancement sight cannot regress or substitute its basis"); + } + } + replace_latest_sight( + node.cache(), + &backing, + WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_TYPE, + &key, + &entry, + &opening, + )?; + Ok(entry) +} + +pub(crate) fn write_workspace_coverage_terminal_sight( + local_verse_store: impl AsRef, + runtime_id: &str, + entry: WorkspaceCoverageTerminalSightEntry, +) -> Result { + validate_terminal_sight_shape(&entry, true)?; + if entry.runtime_id != runtime_id { + bail!("workspace coverage terminal sight runtime argument disagrees"); + } + let backing = SingleFileMessagePackBackingStore::new(local_verse_store.as_ref()); + let node = open_epiphany_cultmesh_node(local_verse_store.as_ref(), runtime_id.to_string())?; + let key = terminal_sight_key( + runtime_id, + entry.body_generation, + &entry.body_observation_id, + ); + let opening = backing.pull_all()?; + if let Some(prior) = opening.iter().find(|envelope| { + envelope.r#type == WORKSPACE_COVERAGE_TERMINAL_SIGHT_TYPE && envelope.key == key + }) { + let prior: WorkspaceCoverageTerminalSightEntry = rmp_serde::from_slice(&prior.payload)?; + validate_terminal_sight_shape(&prior, true)?; + let mut unsigned = prior.clone(); + unsigned.provider_signature.clear(); + verify_sight_signature( + COVERAGE_TERMINAL_SIGHT_DOMAIN, + &unsigned, + &prior.provider_public_key, + &prior.provider_signature, + )?; + if prior == entry { + return Ok(entry); + } + bail!("workspace coverage terminal sight is immutable for its exact Body basis"); + } + replace_latest_sight( + node.cache(), + &backing, + WORKSPACE_COVERAGE_TERMINAL_SIGHT_TYPE, + &key, + &entry, + &opening, + )?; + Ok(entry) +} + +/// Publishes operator sight only after the owned coverage store proves a +/// current durable checkpoint/progress join. The returned document grants no +/// authority over that store. +#[allow(clippy::too_many_arguments)] +pub(crate) fn publish_workspace_coverage_advancement_sight( + local_verse_store: &Path, + runtime_store: &Path, + coverage: &crate::WorkspaceCoverageAuthority, + runtime_id: &str, + launch_id: &str, + trusted_host: &HostIncarnationIdentityEntry, + provider: &SigningKey, + observed_at: chrono::DateTime, + no_advance_lease: chrono::Duration, +) -> Result { + let advancing = crate::authenticate_current_workspace_coverage_advancement( + Path::new(&coverage.runtime_body_route.body_store_path), + &coverage.store, + local_verse_store, + runtime_id, + launch_id, + trusted_host, + observed_at, + no_advance_lease, + )? + .ok_or_else(|| anyhow!("owned workspace coverage has no current advancing authority"))?; + let opening = coverage.store.pull_all()?; + let progress_env = opening + .iter() + .find(|env| { + env.r#type == crate::WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE && { + rmp_serde::from_slice::( + &env.payload, + ) + .is_ok_and(|progress| progress.progress_id == advancing.progress_id) + } + }) + .ok_or_else(|| anyhow!("advancement sight progress envelope is absent"))?; + let progress: crate::WorkspaceCoverageProjectionProgressEntry = + rmp_serde::from_slice(&progress_env.payload)?; + let checkpoint_env = opening.iter().find(|env| env.r#type == crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_TYPE && { + rmp_serde::from_slice::(&env.payload) + .is_ok_and(|checkpoint| checkpoint.checkpoint_id == advancing.checkpoint_id) + }).ok_or_else(|| anyhow!("advancement sight checkpoint envelope is absent"))?; + let (launch, launch_digest) = + authenticate_workspace_coverage_managed_process_launch_with_envelope_digest( + local_verse_store, + runtime_id, + launch_id, + trusted_host, + )?; + let basis = crate::load_current_runtime_repository_body_basis(runtime_store)?; + let mut entry = WorkspaceCoverageAdvancementSightEntry { + schema_version: WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION.into(), + runtime_id: runtime_id.into(), + workspace_id: basis.workspace_id, + launch_id: launch_id.into(), + launch_envelope_digest: launch_digest, + provider_incarnation_id: launch.provider_incarnation_id, + provider_public_key: launch.provider_public_key, + coverage_store_binding_id: coverage.store_binding.binding_id.clone(), + coverage_store_binding_envelope_digest: coverage.store_binding_envelope_sha256.clone(), + coverage_store_file_identity: coverage.store_binding.store_file_identity.clone(), + runtime_coverage_route_envelope_digest: coverage + .runtime_coverage_route_envelope_sha256 + .clone(), + body_binding_sha256: basis.body_binding_sha256, + body_observation_id: basis.observation_id, + body_generation: basis.generation, + manifest_root_sha256: basis.manifest_root_sha256, + claim_id: advancing.claim_id, + claim_epoch: advancing.claim_epoch, + plan_id: advancing.plan_id, + progress_id: advancing.progress_id, + progress_envelope_digest: envelope_digest(progress_env), + checkpoint_id: advancing.checkpoint_id, + checkpoint_envelope_digest: envelope_digest(checkpoint_env), + sequence: progress.sequence, + status: "warming".into(), + completed_units: advancing.completed_units, + total_units: advancing.total_units, + last_advanced_at_utc: advancing.last_advanced_at_utc, + observed_at_utc: observed_at.to_rfc3339(), + provider_signature: Vec::new(), + signature_algorithm: "ed25519".into(), + }; + validate_workspace_coverage_sight_closing_authority( + runtime_store, + coverage, + &entry.workspace_id, + &entry.body_binding_sha256, + &entry.body_observation_id, + entry.body_generation, + &entry.manifest_root_sha256, + )?; + sign_workspace_coverage_advancement_sight(&mut entry, provider)?; + write_workspace_coverage_advancement_sight(local_verse_store, runtime_id, entry) +} + +pub(crate) fn publish_workspace_coverage_terminal_sight( + local_verse_store: &Path, + runtime_store: &Path, + coverage: &crate::WorkspaceCoverageAuthority, + runtime_id: &str, + launch_id: &str, + trusted_host: &HostIncarnationIdentityEntry, + provider: &SigningKey, + observed_at: chrono::DateTime, +) -> Result { + let terminal = crate::workspace_coverage_projector::authenticate_current_workspace_coverage_terminal_authority_with_store( + runtime_store, &coverage.store, + )?.ok_or_else(|| anyhow!("owned workspace coverage has no current terminal authority"))?; + if terminal.managed_process_launch_id != launch_id { + bail!("terminal sight launch disagrees with terminal coverage authority"); + } + if let Some(existing) = authenticate_current_workspace_coverage_terminal_sight( + runtime_store, + local_verse_store, + runtime_id, + trusted_host, + )? { + if existing.launch_id == launch_id + && existing.claim_id == terminal.claim_id + && existing.claim_epoch == terminal.claim_epoch + && existing.plan_id == terminal.plan_id + && existing.receipt_id == terminal.receipt_id + { + return Ok(existing); + } + bail!("current terminal sight disagrees with owned terminal authority"); + } + let opening = coverage.store.pull_all()?; + let receipt_env = opening + .iter() + .find(|env| { + env.r#type == "gamecult.epiphany.workspace_coverage_receipt" && { + rmp_serde::from_slice::< + crate::workspace_retrieval_coverage::WorkspaceCoverageReceipt, + >(&env.payload) + .is_ok_and(|receipt| receipt.receipt_id == terminal.receipt_id) + } + }) + .ok_or_else(|| anyhow!("terminal sight receipt envelope is absent"))?; + let head_env = opening + .iter() + .find(|env| { + env.r#type == "gamecult.epiphany.workspace_coverage_head" && env.key == "current" + }) + .ok_or_else(|| anyhow!("terminal sight head envelope is absent"))?; + let (launch, launch_digest) = + authenticate_workspace_coverage_managed_process_launch_with_envelope_digest( + local_verse_store, + runtime_id, + launch_id, + trusted_host, + )?; + let basis = crate::load_current_runtime_repository_body_basis(runtime_store)?; + let mut entry = WorkspaceCoverageTerminalSightEntry { + schema_version: WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION.into(), + runtime_id: runtime_id.into(), + workspace_id: basis.workspace_id, + launch_id: launch_id.into(), + launch_envelope_digest: launch_digest, + provider_incarnation_id: launch.provider_incarnation_id, + provider_public_key: launch.provider_public_key, + coverage_store_binding_id: coverage.store_binding.binding_id.clone(), + coverage_store_binding_envelope_digest: coverage.store_binding_envelope_sha256.clone(), + coverage_store_file_identity: coverage.store_binding.store_file_identity.clone(), + runtime_coverage_route_envelope_digest: coverage + .runtime_coverage_route_envelope_sha256 + .clone(), + body_binding_sha256: basis.body_binding_sha256, + body_observation_id: terminal.body_observation_id, + body_generation: terminal.body_generation, + manifest_root_sha256: basis.manifest_root_sha256, + claim_id: terminal.claim_id, + claim_epoch: terminal.claim_epoch, + plan_id: terminal.plan_id, + receipt_id: terminal.receipt_id, + receipt_envelope_digest: envelope_digest(receipt_env), + head_id: "current".into(), + head_envelope_digest: envelope_digest(head_env), + sequence: terminal.claim_epoch, + status: "succeeded".into(), + observed_at_utc: observed_at.to_rfc3339(), + provider_signature: Vec::new(), + signature_algorithm: "ed25519".into(), + }; + validate_workspace_coverage_sight_closing_authority( + runtime_store, + coverage, + &entry.workspace_id, + &entry.body_binding_sha256, + &entry.body_observation_id, + entry.body_generation, + &entry.manifest_root_sha256, + )?; + sign_workspace_coverage_terminal_sight(&mut entry, provider)?; + write_workspace_coverage_terminal_sight(local_verse_store, runtime_id, entry) +} + +pub(crate) fn validate_workspace_coverage_sight_closing_authority( + runtime_store: &Path, + coverage: &crate::WorkspaceCoverageAuthority, + expected_workspace_id: &str, + expected_body_binding_sha256: &str, + expected_body_observation_id: &str, + expected_body_generation: u64, + expected_manifest_root_sha256: &str, +) -> Result<()> { + let closing_basis = crate::load_current_runtime_repository_body_basis(runtime_store)?; + let closing_route = crate::runtime_workspace_coverage_store_binding(runtime_store)? + .ok_or_else(|| anyhow!("runtime lost workspace coverage route before sight publication"))?; + if closing_basis.workspace_id != expected_workspace_id + || closing_basis.body_binding_sha256 != expected_body_binding_sha256 + || closing_basis.observation_id != expected_body_observation_id + || closing_basis.generation != expected_body_generation + || closing_basis.manifest_root_sha256 != expected_manifest_root_sha256 + || closing_route != coverage.runtime_coverage_route + { + bail!("Repository Body or coverage route moved before sight publication"); + } + Ok(()) +} + +fn replace_latest_sight( + cache: &cultcache_rs::CultCache, + backing: &SingleFileMessagePackBackingStore, + ty: &str, + key: &str, + entry: &T, + opening: &[CultCacheEnvelope], +) -> Result<()> { + let expected = opening + .iter() + .filter(|envelope| envelope.r#type == ty && envelope.key == key) + .cloned() + .collect::>(); + if expected.len() > 1 { + bail!("workspace coverage sight latest identity is duplicated"); + } + let replacement = cache.prepare_entry(key, entry)?.0; + if !backing.compare_and_swap_batch(&expected, vec![replacement])? { + bail!("workspace coverage sight lost exact latest compare-and-swap"); + } + Ok(()) +} + +pub fn authenticate_current_workspace_coverage_advancement_sight( + runtime_store: impl AsRef, + local_verse_store: impl AsRef, + runtime_id: &str, + launch_id: &str, + host: &HostIncarnationIdentityEntry, +) -> Result> { + let basis = crate::load_current_runtime_repository_body_basis(runtime_store.as_ref())?; + let local = SingleFileMessagePackBackingStore::new(local_verse_store.as_ref()).pull_all()?; + let prefix = format!("epiphany-local/workspace-coverage/advancement-sight/{launch_id}/"); + let mut matches = Vec::new(); + for envelope in local.iter().filter(|envelope| { + envelope.r#type == WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_TYPE + && envelope.key.starts_with(&prefix) + }) { + let entry: WorkspaceCoverageAdvancementSightEntry = + rmp_serde::from_slice(&envelope.payload)?; + validate_advancement_sight_shape(&entry, true)?; + if envelope.key != advancement_sight_key(&entry.launch_id, &entry.claim_id) { + bail!("workspace coverage advancement sight key disagrees with signed identity"); + } + if entry.body_observation_id == basis.observation_id + && entry.body_generation == basis.generation + { + matches.push((envelope, entry)); + } + } + if matches.len() > 1 { + bail!("workspace coverage launch has multiple current advancement sights"); + } + let Some((_, entry)) = matches.first() else { + return Ok(None); + }; + let entry = entry.clone(); + authenticate_advancement_sight( + &entry, + runtime_store.as_ref(), + local_verse_store.as_ref(), + runtime_id, + launch_id, + host, + )?; + Ok(Some(entry)) +} + +pub fn authenticate_current_workspace_coverage_terminal_sight( + runtime_store: impl AsRef, + local_verse_store: impl AsRef, + runtime_id: &str, + host: &HostIncarnationIdentityEntry, +) -> Result> { + let basis = crate::load_current_runtime_repository_body_basis(runtime_store.as_ref())?; + let key = terminal_sight_key(runtime_id, basis.generation, &basis.observation_id); + let local = SingleFileMessagePackBackingStore::new(local_verse_store.as_ref()).pull_all()?; + let matches = local + .iter() + .filter(|envelope| { + envelope.r#type == WORKSPACE_COVERAGE_TERMINAL_SIGHT_TYPE && envelope.key == key + }) + .collect::>(); + if matches.len() > 1 { + bail!("workspace coverage terminal sight identity is duplicated"); + } + let Some(envelope) = matches.first() else { + return Ok(None); + }; + let entry: WorkspaceCoverageTerminalSightEntry = rmp_serde::from_slice(&envelope.payload)?; + authenticate_terminal_sight( + &entry, + runtime_store.as_ref(), + local_verse_store.as_ref(), + runtime_id, + host, + )?; + Ok(Some(entry)) +} + +fn authenticate_advancement_sight( + entry: &WorkspaceCoverageAdvancementSightEntry, + runtime_store: &Path, + local_verse_store: &Path, + runtime_id: &str, + launch_id: &str, + host: &HostIncarnationIdentityEntry, +) -> Result<()> { + validate_advancement_sight_shape(entry, true)?; + if entry.runtime_id != runtime_id || entry.launch_id != launch_id { + bail!("workspace coverage advancement sight identity disagrees"); + } + authenticate_sight_common( + runtime_store, + local_verse_store, + runtime_id, + host, + &entry.launch_id, + &entry.launch_envelope_digest, + &entry.provider_incarnation_id, + &entry.provider_public_key, + &entry.workspace_id, + &entry.coverage_store_binding_id, + &entry.coverage_store_binding_envelope_digest, + &entry.coverage_store_file_identity, + &entry.runtime_coverage_route_envelope_digest, + &entry.body_binding_sha256, + &entry.body_observation_id, + entry.body_generation, + &entry.manifest_root_sha256, + )?; + let mut unsigned = entry.clone(); + unsigned.provider_signature.clear(); + verify_sight_signature( + COVERAGE_ADVANCEMENT_SIGHT_DOMAIN, + &unsigned, + &entry.provider_public_key, + &entry.provider_signature, + ) +} + +fn authenticate_terminal_sight( + entry: &WorkspaceCoverageTerminalSightEntry, + runtime_store: &Path, + local_verse_store: &Path, + runtime_id: &str, + host: &HostIncarnationIdentityEntry, +) -> Result<()> { + validate_terminal_sight_shape(entry, true)?; + if entry.runtime_id != runtime_id { + bail!("workspace coverage terminal sight identity disagrees"); + } + authenticate_sight_common( + runtime_store, + local_verse_store, + runtime_id, + host, + &entry.launch_id, + &entry.launch_envelope_digest, + &entry.provider_incarnation_id, + &entry.provider_public_key, + &entry.workspace_id, + &entry.coverage_store_binding_id, + &entry.coverage_store_binding_envelope_digest, + &entry.coverage_store_file_identity, + &entry.runtime_coverage_route_envelope_digest, + &entry.body_binding_sha256, + &entry.body_observation_id, + entry.body_generation, + &entry.manifest_root_sha256, + )?; + let mut unsigned = entry.clone(); + unsigned.provider_signature.clear(); + verify_sight_signature( + COVERAGE_TERMINAL_SIGHT_DOMAIN, + &unsigned, + &entry.provider_public_key, + &entry.provider_signature, + ) +} + +#[allow(clippy::too_many_arguments)] +fn authenticate_sight_common( + runtime_store: &Path, + local_verse_store: &Path, + runtime_id: &str, + host: &HostIncarnationIdentityEntry, + launch_id: &str, + launch_digest: &str, + provider_incarnation_id: &str, + provider_public_key: &[u8], + workspace_id: &str, + binding_id: &str, + binding_envelope_digest: &str, + store_file_identity: &str, + runtime_route_digest: &str, + body_binding_sha256: &str, + body_observation_id: &str, + body_generation: u64, + manifest_root_sha256: &str, +) -> Result<()> { + let (launch, exact_launch_digest) = + authenticate_workspace_coverage_managed_process_launch_with_envelope_digest( + local_verse_store, + runtime_id, + launch_id, + host, + )?; + if exact_launch_digest != launch_digest + || launch.provider_incarnation_id != provider_incarnation_id + || launch.provider_public_key != provider_public_key + { + bail!("workspace coverage sight disagrees with exact managed launch"); + } + let basis = crate::load_current_runtime_repository_body_basis(runtime_store)?; + if basis.runtime_id != runtime_id + || basis.workspace_id != workspace_id + || basis.body_binding_sha256 != body_binding_sha256 + || basis.observation_id != body_observation_id + || basis.generation != body_generation + || basis.manifest_root_sha256 != manifest_root_sha256 + { + bail!("workspace coverage sight disagrees with current repository Body basis"); + } + let route = crate::runtime_workspace_coverage_store_binding(runtime_store)? + .ok_or_else(|| anyhow!("runtime has no workspace coverage store route"))?; + if route.binding_id != binding_id + || route.store_file_identity != store_file_identity + || route.runtime_id != runtime_id + || route.workspace_id != workspace_id + || route.body_binding_sha256 != body_binding_sha256 + { + bail!("workspace coverage sight disagrees with current coverage route"); + } + let opening = SingleFileMessagePackBackingStore::new(runtime_store).pull_all()?; + let route_env = opening + .iter() + .find(|env| { + env.r#type == crate::RUNTIME_WORKSPACE_COVERAGE_STORE_BINDING_TYPE + && env.key == crate::RUNTIME_WORKSPACE_COVERAGE_STORE_BINDING_KEY + }) + .ok_or_else(|| anyhow!("runtime workspace coverage route envelope is absent"))?; + let exact_route_digest = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(route_env)?)); + if exact_route_digest != runtime_route_digest { + bail!("workspace coverage sight route envelope was substituted"); + } + let body_route = crate::runtime_repository_body_store_binding(runtime_store)? + .ok_or_else(|| anyhow!("runtime has no repository Body route"))?; + let body_opening = + SingleFileMessagePackBackingStore::new(&body_route.body_store_path).pull_all()?; + let body_binding_env = body_opening + .iter() + .find(|env| env.r#type == crate::BODY_BINDING_TYPE && env.key == crate::BODY_BINDING_KEY) + .ok_or_else(|| anyhow!("repository Body binding envelope is absent"))?; + let body_binding: crate::RepositoryBodyBinding = + rmp_serde::from_slice(&body_binding_env.payload)?; + let local_binding = crate::WorkspaceCoverageStoreBinding { + schema_version: crate::WORKSPACE_COVERAGE_STORE_BINDING_SCHEMA_VERSION.into(), + binding_id: route.binding_id.clone(), + runtime_id: route.runtime_id.clone(), + swarm_id: route.swarm_id.clone(), + workspace_id: route.workspace_id.clone(), + store_file_identity: route.store_file_identity.clone(), + body_binding_sha256: route.body_binding_sha256.clone(), + repository_source_identity_sha256: body_binding.source_identity_sha256, + projection_scope: "workspace_coverage".into(), + storage_backend: "cultcache_redb_v0".into(), + created_at_utc: route.created_at_utc.clone(), + }; + let reconstructed = CultCacheEnvelope { + key: crate::WORKSPACE_COVERAGE_STORE_BINDING_KEY.into(), + r#type: crate::WORKSPACE_COVERAGE_STORE_BINDING_TYPE.into(), + payload: rmp_serde::to_vec(&local_binding)?, + stored_at: route.created_at_utc, + schema_id: Some(crate::WORKSPACE_COVERAGE_STORE_BINDING_TYPE.into()), + }; + let exact_binding_digest = format!( + "{:x}", + Sha256::digest(rmp_serde::to_vec_named(&reconstructed)?) + ); + if exact_binding_digest != binding_envelope_digest { + bail!("workspace coverage sight binding envelope was substituted"); + } + Ok(()) +} + +fn verify_sight_signature( + domain: &[u8], + entry: &T, + public_key: &[u8], + signature: &[u8], +) -> Result<()> { + let verifying = VerifyingKey::from_bytes( + public_key + .try_into() + .map_err(|_| anyhow!("workspace coverage sight public key must be 32 bytes"))?, + )?; + let signature = Signature::from_slice(signature)?; + verifying.verify(&signed_sight_statement(domain, entry)?, &signature)?; + Ok(()) +} + +fn validate_advancement_sight_shape( + entry: &WorkspaceCoverageAdvancementSightEntry, + signed: bool, +) -> Result<()> { + if entry.schema_version != WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION + || entry.status != "warming" + || entry.sequence == 0 + || entry.claim_epoch == 0 + || entry.body_generation == 0 + || entry.completed_units == 0 + || entry.completed_units > entry.total_units + { + bail!("workspace coverage advancement sight shape is invalid"); + } + validate_sight_strings(&[ + &entry.runtime_id, + &entry.workspace_id, + &entry.launch_id, + &entry.launch_envelope_digest, + &entry.provider_incarnation_id, + &entry.coverage_store_binding_id, + &entry.coverage_store_binding_envelope_digest, + &entry.coverage_store_file_identity, + &entry.runtime_coverage_route_envelope_digest, + &entry.body_binding_sha256, + &entry.body_observation_id, + &entry.manifest_root_sha256, + &entry.claim_id, + &entry.plan_id, + &entry.progress_id, + &entry.progress_envelope_digest, + &entry.checkpoint_id, + &entry.checkpoint_envelope_digest, + &entry.last_advanced_at_utc, + &entry.observed_at_utc, + ])?; + DateTime::parse_from_rfc3339(&entry.last_advanced_at_utc)?; + DateTime::parse_from_rfc3339(&entry.observed_at_utc)?; + if entry.signature_algorithm != "ed25519" + || entry.provider_public_key.len() != 32 + || (signed && entry.provider_signature.len() != 64) + || (!signed && !entry.provider_signature.is_empty()) + { + bail!("workspace coverage advancement sight signature shape is invalid"); + } + Ok(()) +} + +fn validate_terminal_sight_shape( + entry: &WorkspaceCoverageTerminalSightEntry, + signed: bool, +) -> Result<()> { + if entry.schema_version != WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION + || entry.status != "succeeded" + || entry.sequence == 0 + || entry.claim_epoch == 0 + || entry.body_generation == 0 + || entry.head_id != "current" + { + bail!("workspace coverage terminal sight shape is invalid"); + } + validate_sight_strings(&[ + &entry.runtime_id, + &entry.workspace_id, + &entry.launch_id, + &entry.launch_envelope_digest, + &entry.provider_incarnation_id, + &entry.coverage_store_binding_id, + &entry.coverage_store_binding_envelope_digest, + &entry.coverage_store_file_identity, + &entry.runtime_coverage_route_envelope_digest, + &entry.body_binding_sha256, + &entry.body_observation_id, + &entry.manifest_root_sha256, + &entry.claim_id, + &entry.plan_id, + &entry.receipt_id, + &entry.receipt_envelope_digest, + &entry.head_envelope_digest, + &entry.observed_at_utc, + ])?; + DateTime::parse_from_rfc3339(&entry.observed_at_utc)?; + if entry.signature_algorithm != "ed25519" + || entry.provider_public_key.len() != 32 + || (signed && entry.provider_signature.len() != 64) + || (!signed && !entry.provider_signature.is_empty()) + { + bail!("workspace coverage terminal sight signature shape is invalid"); + } + Ok(()) +} + +fn validate_sight_strings(values: &[&str]) -> Result<()> { + if values.iter().any(|value| value.trim().is_empty()) { + bail!("workspace coverage sight has an empty identity or digest"); + } + Ok(()) +} fn validate_digest(name: &str, value: &str) -> Result<()> { if value.len() != 71 || !value.starts_with("sha256-") @@ -1816,6 +2737,287 @@ mod tests { Ok((store, host, launch)) } + fn advancement_sight( + provider: &SigningKey, + sequence: u64, + ) -> Result { + let mut entry = WorkspaceCoverageAdvancementSightEntry { + schema_version: WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION.into(), + runtime_id: "local".into(), + workspace_id: "workspace".into(), + launch_id: Uuid::new_v4().to_string(), + launch_envelope_digest: "launch-digest".into(), + provider_incarnation_id: Uuid::new_v4().to_string(), + provider_public_key: provider.verifying_key().to_bytes().to_vec(), + coverage_store_binding_id: "binding".into(), + coverage_store_binding_envelope_digest: "binding-envelope".into(), + coverage_store_file_identity: "file-identity".into(), + runtime_coverage_route_envelope_digest: "route-envelope".into(), + body_binding_sha256: "body-binding".into(), + body_observation_id: "observation".into(), + body_generation: 7, + manifest_root_sha256: "manifest".into(), + claim_id: "claim".into(), + claim_epoch: 3, + plan_id: "plan".into(), + progress_id: Uuid::new_v4().to_string(), + progress_envelope_digest: "progress-envelope".into(), + checkpoint_id: Uuid::new_v4().to_string(), + checkpoint_envelope_digest: "checkpoint-envelope".into(), + sequence, + status: "warming".into(), + completed_units: sequence, + total_units: 10, + last_advanced_at_utc: chrono::Utc::now().to_rfc3339(), + observed_at_utc: chrono::Utc::now().to_rfc3339(), + provider_signature: Vec::new(), + signature_algorithm: "ed25519".into(), + }; + sign_workspace_coverage_advancement_sight(&mut entry, provider)?; + Ok(entry) + } + + #[test] + fn advancement_sight_signature_refuses_substitution_and_storage_is_latest_only() -> Result<()> { + let provider = provider_key(); + let temp = tempfile::tempdir()?; + let store = temp.path().join("verse.ccmp"); + let first = advancement_sight(&provider, 1)?; + write_workspace_coverage_advancement_sight(&store, "local", first.clone())?; + let mut second = advancement_sight(&provider, 2)?; + second.launch_id = first.launch_id.clone(); + second.provider_incarnation_id = first.provider_incarnation_id.clone(); + second.claim_id = first.claim_id.clone(); + sign_workspace_coverage_advancement_sight(&mut second, &provider)?; + write_workspace_coverage_advancement_sight(&store, "local", second.clone())?; + let sights = SingleFileMessagePackBackingStore::new(&store) + .pull_all()? + .into_iter() + .filter(|entry| entry.r#type == WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_TYPE) + .collect::>(); + assert_eq!( + sights.len(), + 1, + "advancement sight must replace its exact latest projection" + ); + assert_eq!( + rmp_serde::from_slice::(&sights[0].payload)?, + second + ); + + let mut regression = first.clone(); + regression.launch_id = second.launch_id.clone(); + regression.provider_incarnation_id = second.provider_incarnation_id.clone(); + regression.claim_id = second.claim_id.clone(); + sign_workspace_coverage_advancement_sight(&mut regression, &provider)?; + assert!(write_workspace_coverage_advancement_sight(&store, "local", regression).is_err()); + + let mut substituted = second.clone(); + substituted.checkpoint_envelope_digest = "alien-checkpoint".into(); + let mut unsigned = substituted.clone(); + unsigned.provider_signature.clear(); + assert!( + verify_sight_signature( + COVERAGE_ADVANCEMENT_SIGHT_DOMAIN, + &unsigned, + &substituted.provider_public_key, + &substituted.provider_signature, + ) + .is_err() + ); + Ok(()) + } + + #[test] + fn first_checkpoint_survives_owned_store_reopen_and_resumes_to_terminal_without_body_copies() + -> Result<()> { + let temp = tempfile::tempdir()?; + let verse = temp.path().join("verse.ccmp"); + let host = enroll_host_identity_at(&temp.path().join("host.ccmp"))?; + let policy = policy()?; + let mut node = open_epiphany_cultmesh_node(&verse, "local")?; + node.put(managed_policy_key(), &policy)?; + let policy_envelope = node + .cache() + .get_envelope::(&managed_policy_key())? + .context("test policy envelope absent")?; + let provider = provider_key(); + let launch = launch(&policy, envelope_digest(&policy_envelope), &host, &provider)?; + write_workspace_coverage_managed_process_launch( + &verse, + "local", + launch.clone(), + host.entry(), + )?; + + let repo = tempfile::tempdir()?; + let initialized = std::process::Command::new("git") + .arg("init") + .current_dir(repo.path()) + .output()?; + if !initialized.status.success() { + bail!("resume fixture failed to initialize repository"); + } + std::fs::write(repo.path().join("source.rs"), "fn resumed() {}\n")?; + let runtime = temp.path().join("runtime.cc"); + let agents = temp.path().join("agents.cc"); + let body_store = temp.path().join("body.cc"); + let coverage_path = std::fs::canonicalize(temp.path())?.join("coverage.redb"); + crate::initialize_runtime_spine( + &runtime, + crate::RuntimeSpineInitOptions { + runtime_id: "local".into(), + display_name: "checkpoint resume".into(), + created_at: "2026-07-17T00:00:00Z".into(), + }, + )?; + crate::ensure_agent_memory_swarm_identity(&agents, "resume-swarm")?; + crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-17T00:00:01Z")?; + crate::bind_repository_body(repo.path(), &body_store, &runtime, "resume-workspace")?; + crate::bind_runtime_workspace_coverage_store( + &runtime, + &coverage_path, + "2026-07-17T00:00:02Z", + )?; + let basis = crate::observe_runtime_repository_body_basis(&runtime)?; + let session = crate::RepositoryBodyReadSession::open(&runtime, &basis)?; + let prepared = crate::workspace_coverage_projector::prepare_workspace_coverage_projection( + &session, + "test-provider", + "test-model", + 3, + )?; + let authority = crate::open_workspace_coverage_authority(&runtime)?; + let acquisition = + match crate::workspace_coverage_projector::acquire_workspace_coverage_projection( + &prepared, + &authority.store, + EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, + &launch.provider_incarnation_id, + &launch.launch_id, + )? { + crate::workspace_coverage_projector::WorkspaceCoverageAcquireResult::Acquired( + value, + ) => value, + _ => bail!("resume fixture did not acquire projection"), + }; + let body_before = std::fs::read(&body_store)?; + crate::workspace_coverage_projection_progress::publish_workspace_coverage_progress_genesis( + &body_store, + &authority.store, + &verse, + "local", + host.entry(), + &provider, + 30_000, + )?; + let vector = vec![0.25_f32; 3]; + let mut point_bindings = Vec::new(); + let mut vector_bindings = Vec::new(); + let mut stored = Vec::new(); + for point in &acquisition.plan.planned_points { + let payload = crate::workspace_coverage_projector::payload_for( + &acquisition.obligation, + &acquisition.plan, + point, + ); + point_bindings.push(crate::WorkspaceCoveragePointBinding { + point_id: point.point_id.clone(), + payload_sha256: format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&payload)?)), + }); + vector_bindings.push(crate::WorkspaceCoverageVectorBinding { + point_id: point.point_id.clone(), + vector_sha256: format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&vector)?)), + }); + stored.push(crate::semantic_backend::SemanticStoredPoint { + id: point.point_id.clone(), + payload: Some(payload), + vector: Some(vector.clone()), + }); + } + crate::workspace_coverage_projection_batch_checkpoint::admit_observed_workspace_coverage_batch( + &body_store, + &authority.store, + &verse, + "local", + host.entry(), + &provider, + crate::workspace_coverage_projection_batch_checkpoint::ObservedWorkspaceCoverageBatchInput { + claim_id: acquisition.claim.claim_id.clone(), + attempt_id: acquisition.attempt.attempt_id.clone(), + plan_id: acquisition.plan.plan_id.clone(), + first_plan_ordinal: 0, + point_bindings, + vector_bindings, + }, + )?; + let claim_id = acquisition.claim.claim_id.clone(); + let claim_epoch = acquisition.claim.claim_epoch; + drop(acquisition); + drop(authority); + + let reopened = crate::open_workspace_coverage_authority(&runtime)?; + let chain = crate::workspace_coverage_projection_batch_checkpoint::load_authenticated_checkpoint_chain( + &body_store, + &reopened.store, + &verse, + host.entry(), + &claim_id, + claim_epoch, + )?; + assert_eq!(chain.len(), 1); + assert!( + crate::authenticate_current_workspace_coverage_advancement( + &body_store, + &reopened.store, + &verse, + "local", + &launch.launch_id, + host.entry(), + chrono::Utc::now(), + chrono::Duration::minutes(5), + )? + .is_some() + ); + let collection = crate::workspace_coverage_execution_collection( + &prepared.plan.plan_id, + &claim_id, + claim_epoch, + )?; + let obligation = prepared.obligation.clone(); + let plan = prepared.plan.clone(); + let observed = crate::workspace_coverage_projector::observe_final_projection_against_authenticated_checkpoint_chain( + &obligation, + &plan, + &collection, + stored, + &chain, + )?; + let resumed = + match crate::workspace_coverage_projector::acquire_workspace_coverage_projection( + &prepared, + &reopened.store, + EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, + &launch.provider_incarnation_id, + &launch.launch_id, + )? { + crate::workspace_coverage_projector::WorkspaceCoverageAcquireResult::Acquired( + value, + ) => value, + _ => bail!("reopened exact executor did not resume claim"), + }; + crate::workspace_coverage_projector::commit_workspace_coverage_success(&resumed, observed)?; + assert_eq!(std::fs::read(&body_store)?, body_before); + assert!(reopened.store.pull_all()?.iter().all(|entry| !matches!( + entry.r#type.as_str(), + crate::BODY_BINDING_TYPE + | crate::BODY_HEAD_TYPE + | crate::BODY_OBSERVATION_TYPE + | crate::BODY_MANIFEST_TYPE + ))); + Ok(()) + } + #[test] fn signed_launch_and_per_launch_heartbeat_chain_is_exact() -> Result<()> { let temp = tempfile::tempdir()?; @@ -2145,6 +3347,13 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "recovery-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-16T00:00:01Z")?; crate::bind_repository_body(&repo, &body_store, &runtime, "recovery-workspace")?; + let coverage_store_path = std::fs::canonicalize(temp.path())?.join("coverage.redb"); + crate::bind_runtime_workspace_coverage_store( + &runtime, + &coverage_store_path, + "2026-07-16T00:00:02Z", + )?; + let coverage = crate::open_workspace_coverage_authority(&runtime)?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; let session = crate::RepositoryBodyReadSession::open(&runtime, &basis)?; let prepared = crate::workspace_coverage_projector::prepare_workspace_coverage_projection( @@ -2156,6 +3365,7 @@ mod tests { let acquired = match crate::workspace_coverage_projector::acquire_workspace_coverage_projection( &prepared, + &coverage.store, EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, &old_launch.provider_incarnation_id, &old_launch.launch_id, @@ -2184,6 +3394,10 @@ mod tests { &old_launch.launch_id, host.entry(), )?; + let old_claim_id = acquired.claim.claim_id.clone(); + let old_claim_epoch = acquired.claim.claim_epoch; + drop(acquired); + drop(coverage); let node = open_epiphany_cultmesh_node(&verse, "local")?; let policy_envelope = node @@ -2231,7 +3445,7 @@ mod tests { &old_launch.launch_id, &out_of_order.launch_id, &out_of_order_ready.heartbeat_id, - &acquired.claim.claim_id, + &old_claim_id, ) .is_err(), "unbound replacement must be refused" @@ -2310,7 +3524,7 @@ mod tests { &old_launch.launch_id, &replacement.launch_id, °raded.heartbeat_id, - &acquired.claim.claim_id, + &old_claim_id, ) .is_err(), "degraded replacement must not inherit Body authority" @@ -2333,16 +3547,18 @@ mod tests { &old_launch.launch_id, &replacement.launch_id, &ready.heartbeat_id, - &acquired.claim.claim_id, + &old_claim_id, )?; - assert_eq!(recovered.claim_epoch, acquired.claim.claim_epoch + 1); + assert_eq!(recovered.claim_epoch, old_claim_epoch + 1); assert_eq!(recovered.managed_process_launch_id, replacement.launch_id); assert_eq!( recovered.executor_incarnation, replacement.provider_incarnation_id ); + let coverage = crate::open_workspace_coverage_authority(&runtime)?; match crate::workspace_coverage_projector::acquire_workspace_coverage_projection( &prepared, + &coverage.store, EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, &replacement.provider_incarnation_id, &replacement.launch_id, @@ -2355,30 +3571,32 @@ mod tests { assert!(matches!( crate::workspace_coverage_projector::acquire_workspace_coverage_projection( &prepared, + &coverage.store, EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, "wrong-incarnation", &replacement.launch_id, )?, crate::workspace_coverage_projector::WorkspaceCoverageAcquireResult::Contended )); - let opening = SingleFileMessagePackBackingStore::new(&body_store).pull_all()?; + let opening = coverage.store.pull_all()?; let old_history: crate::workspace_coverage_projector::WorkspaceCoverageProjectionClaim = rmp_serde::from_slice( &opening .iter() .find(|entry| { entry.r#type == "gamecult.epiphany.workspace_coverage_projection_claim" - && entry.key == format!("history/{}", acquired.claim.claim_id) + && entry.key == format!("history/{old_claim_id}") }) .context("failed claim history missing")? .payload, )?; assert_eq!(old_history.status, "failed"); assert!(old_history.termination_evidence_digest.is_some()); + drop(coverage); let recovery_id = recovered.recovery_receipt_id.as_str(); let recovery_digest = recovered.recovery_receipt_digest.as_str(); crate::workspace_coverage_projector::authenticate_workspace_coverage_recovery_receipt( - &body_store, + &runtime, &verse, "local", host.entry(), @@ -2402,7 +3620,7 @@ mod tests { &old_launch.launch_id, &replacement.launch_id, &ready.heartbeat_id, - &acquired.claim.claim_id, + &old_claim_id, ) .is_err(), "moved claim/attempt must refuse replay" diff --git a/epiphany-core/src/workspace_coverage_projection_batch_checkpoint.rs b/epiphany-core/src/workspace_coverage_projection_batch_checkpoint.rs index bdba6e08..3dae40cf 100644 --- a/epiphany-core/src/workspace_coverage_projection_batch_checkpoint.rs +++ b/epiphany-core/src/workspace_coverage_projection_batch_checkpoint.rs @@ -1,9 +1,9 @@ use crate::workspace_coverage_process_documents::authenticate_workspace_coverage_managed_process_launch_with_envelope_digest; use crate::workspace_coverage_projector::{ - ATTEMPT_TYPE, CLAIM_KEY, CLAIM_TYPE, OBLIGATION_TYPE, PLAN_TYPE, - WorkspaceCoverageProjectionAttempt, WorkspaceCoverageProjectionClaim, - exact_obligation_body_authority, payload_for, validate_claim_attempt_link, - validate_projection_attempt, validate_projection_claim, + ATTEMPT_TYPE, CLAIM_TYPE, OBLIGATION_TYPE, PLAN_TYPE, WorkspaceCoverageProjectionAttempt, + WorkspaceCoverageProjectionClaim, exact_obligation_body_authority, payload_for, + validate_claim_attempt_link, validate_projection_attempt, validate_projection_claim, + workspace_coverage_claim_key, }; use crate::workspace_retrieval_coverage::{ WorkspaceCoverageObligation, WorkspaceCoverageProjectionPlan, @@ -19,7 +19,8 @@ use crate::{ use anyhow::{Context, Result, anyhow, bail}; use chrono::DateTime; use cultcache_rs::{ - CacheBackingStore, CultCacheEnvelope, DatabaseEntry, SingleFileMessagePackBackingStore, + CacheBackingStore, CultCacheEnvelope, DatabaseEntry, OwnedRedbMessagePackBackingStore, + SingleFileMessagePackBackingStore, }; use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey}; use serde::Serialize; @@ -31,7 +32,9 @@ pub const WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_TYPE: &str = pub const WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_SCHEMA_VERSION: &str = "gamecult.epiphany.workspace_coverage_projection_batch_checkpoint.v0"; pub const WORKSPACE_COVERAGE_BATCH_CHECKPOINT_MAX_POINTS: usize = 128; -const HEAD_TYPE: &str = "gamecult.epiphany.workspace_coverage_projection_batch_checkpoint_head"; +pub(crate) const WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_HEAD_TYPE: &str = + "gamecult.epiphany.workspace_coverage_projection_batch_checkpoint_head"; +const HEAD_TYPE: &str = WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_HEAD_TYPE; const HEAD_SCHEMA: &str = "gamecult.epiphany.workspace_coverage_projection_batch_checkpoint_head.v0"; const OBSERVATION_METHOD: &str = "provider-attested-qdrant-readback-v0"; @@ -184,7 +187,8 @@ pub(crate) struct ObservedWorkspaceCoverageBatchInput { } pub(crate) fn admit_observed_workspace_coverage_batch( - body_store: impl AsRef, + body_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, local_verse_store: impl AsRef, runtime_id: &str, trusted_host: &HostIncarnationIdentityEntry, @@ -192,9 +196,9 @@ pub(crate) fn admit_observed_workspace_coverage_batch( observed: ObservedWorkspaceCoverageBatchInput, ) -> Result { validate_observed_batch_input(&observed)?; - let body_store = body_store.as_ref(); - let opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY)?; + let opening = coverage_store.pull_all()?; + let body_opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + let claim_env = find_current_claim(&opening, &body_opening)?; let claim: WorkspaceCoverageProjectionClaim = decode(claim_env)?; let attempt_env = find(&opening, ATTEMPT_TYPE, &claim.attempt_id)?; let attempt: WorkspaceCoverageProjectionAttempt = decode(attempt_env)?; @@ -211,7 +215,7 @@ pub(crate) fn admit_observed_workspace_coverage_batch( let obligation: WorkspaceCoverageObligation = decode(obligation_env)?; let plan: WorkspaceCoverageProjectionPlan = decode(plan_env)?; validate_workspace_coverage_projection_plan(&obligation, &plan)?; - let authority = exact_obligation_body_authority(&opening, &obligation)?; + let authority = exact_obligation_body_authority(&body_opening, &obligation)?; let binding_env = find(&authority, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; let body_head_env = find(&authority, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; let observation_env = find( @@ -242,36 +246,6 @@ pub(crate) fn admit_observed_workspace_coverage_batch( { bail!("observed batch signer/launch disagrees with claim executor"); } - if let Some(current) = load_authenticated_current_checkpoint( - body_store, - local_verse_store.as_ref(), - trusted_host, - &claim.claim_id, - claim.claim_epoch, - )? { - let progress = crate::workspace_coverage_projection_progress::load_latest_workspace_coverage_projection_progress( - local_verse_store.as_ref(), - runtime_id, - &claim.managed_process_launch_id, - &claim.claim_id, - )? - .ok_or_else(|| anyhow!("current checkpoint exists without canonical progress genesis"))?; - if progress.sequence - != current - .checkpoint - .sequence - .checked_add(1) - .ok_or_else(|| anyhow!("checkpoint sequence exhausted"))? - || progress.checkpoint_id.as_deref() != Some(current.checkpoint.checkpoint_id.as_str()) - || progress.checkpoint_binding_sha256.as_deref() - != Some(current.checkpoint_envelope_digest.as_str()) - || progress.completed_units != current.checkpoint.cumulative_point_count - { - bail!( - "current checkpoint is ahead of progress; reconcile before admitting a new batch" - ); - } - } let head_key = checkpoint_head_key(&claim.claim_id, claim.claim_epoch); let prior: Option = opening .iter() @@ -353,20 +327,23 @@ pub(crate) fn admit_observed_workspace_coverage_batch( sign_workspace_coverage_projection_batch_checkpoint(&mut entry, provider_signing_key)?; admit_workspace_coverage_projection_batch_checkpoint( body_store, + coverage_store, local_verse_store, trusted_host, + provider_signing_key, entry, ) } pub(crate) fn load_authenticated_current_checkpoint( - body_store: impl AsRef, + body_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, local_verse_store: impl AsRef, trusted_host: &HostIncarnationIdentityEntry, claim_id: &str, claim_epoch: u64, ) -> Result> { - let opening = SingleFileMessagePackBackingStore::new(body_store.as_ref()).pull_all()?; + let opening = coverage_store.pull_all()?; let head_key = checkpoint_head_key(claim_id, claim_epoch); let Some(head_env) = opening .iter() @@ -402,21 +379,26 @@ pub(crate) fn load_authenticated_current_checkpoint( )?; validate_launch(&checkpoint, &launch, &launch_digest)?; validate_current_head_event_identity(&checkpoint, &head)?; - let binding_env = find(&opening, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; - let body_head_env = find(&opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; + let body_opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + let binding_env = find(&body_opening, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; + let body_head_env = find(&body_opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; let observation_env = find( - &opening, + &body_opening, BODY_OBSERVATION_TYPE, &checkpoint.body_observation_id, )?; let manifest_env = find( - &opening, + &body_opening, BODY_MANIFEST_TYPE, &checkpoint.manifest_root_sha256, )?; let obligation_env = find(&opening, OBLIGATION_TYPE, &checkpoint.obligation_id)?; let plan_env = find(&opening, PLAN_TYPE, &checkpoint.plan_id)?; - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY)?; + let claim_env = find( + &opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&checkpoint.body_observation_id, checkpoint.body_generation), + )?; let attempt_env = find(&opening, ATTEMPT_TYPE, &checkpoint.attempt_id)?; let binding: RepositoryBodyBinding = decode(binding_env)?; let body_head: RepositoryBodyHead = decode(body_head_env)?; @@ -452,7 +434,7 @@ pub(crate) fn load_authenticated_current_checkpoint( }, )?; validate_workspace_coverage_projection_plan(&obligation, &plan)?; - exact_obligation_body_authority(&opening, &obligation)?; + let body_authority = exact_obligation_body_authority(&body_opening, &obligation)?; validate_authority( &checkpoint, &binding, @@ -473,21 +455,34 @@ pub(crate) fn load_authenticated_current_checkpoint( attempt_env, )?; validate_batch_against_plan(&checkpoint, &obligation, &plan)?; - Ok(Some(WorkspaceCoverageProjectionBatchCheckpointAdmission { + let admission = WorkspaceCoverageProjectionBatchCheckpointAdmission { checkpoint, checkpoint_envelope_digest: head.checkpoint_envelope_digest, - })) + }; + let closing_body = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + for expected in body_authority { + if closing_body + .iter() + .find(|row| row.r#type == expected.r#type && row.key == expected.key) + != Some(&expected) + { + bail!("Repository Body changed while loading current workspace checkpoint"); + } + } + Ok(Some(admission)) } pub(crate) fn load_authenticated_checkpoint_chain( - body_store: impl AsRef, + body_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, local_verse_store: impl AsRef, trusted_host: &HostIncarnationIdentityEntry, claim_id: &str, claim_epoch: u64, ) -> Result> { let Some(current) = load_authenticated_current_checkpoint( - body_store.as_ref(), + body_store, + coverage_store, local_verse_store.as_ref(), trusted_host, claim_id, @@ -496,7 +491,7 @@ pub(crate) fn load_authenticated_checkpoint_chain( else { return Ok(Vec::new()); }; - let opening = SingleFileMessagePackBackingStore::new(body_store.as_ref()).pull_all()?; + let opening = coverage_store.pull_all()?; let head_env = find( &opening, HEAD_TYPE, @@ -508,21 +503,29 @@ pub(crate) fn load_authenticated_checkpoint_chain( { bail!("checkpoint head changed while reconstructing authenticated chain"); } - let binding_env = find(&opening, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; - let body_head_env = find(&opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; + let body_opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + let binding_env = find(&body_opening, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; + let body_head_env = find(&body_opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; let observation_env = find( - &opening, + &body_opening, BODY_OBSERVATION_TYPE, ¤t.checkpoint.body_observation_id, )?; let manifest_env = find( - &opening, + &body_opening, BODY_MANIFEST_TYPE, ¤t.checkpoint.manifest_root_sha256, )?; let obligation_env = find(&opening, OBLIGATION_TYPE, ¤t.checkpoint.obligation_id)?; let plan_env = find(&opening, PLAN_TYPE, ¤t.checkpoint.plan_id)?; - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY)?; + let claim_env = find( + &opening, + CLAIM_TYPE, + &workspace_coverage_claim_key( + ¤t.checkpoint.body_observation_id, + current.checkpoint.body_generation, + ), + )?; let attempt_env = find(&opening, ATTEMPT_TYPE, ¤t.checkpoint.attempt_id)?; let binding: RepositoryBodyBinding = decode(binding_env)?; let body_head: RepositoryBodyHead = decode(body_head_env)?; @@ -558,7 +561,7 @@ pub(crate) fn load_authenticated_checkpoint_chain( }, )?; validate_workspace_coverage_projection_plan(&obligation, &plan)?; - exact_obligation_body_authority(&opening, &obligation)?; + let body_authority = exact_obligation_body_authority(&body_opening, &obligation)?; let (launch, launch_digest) = authenticate_workspace_coverage_managed_process_launch_with_envelope_digest( local_verse_store, @@ -616,6 +619,16 @@ pub(crate) fn load_authenticated_checkpoint_chain( } reversed.reverse(); validate_reconstructed_chain(&reversed, &head)?; + let closing_body = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + for expected in body_authority { + if closing_body + .iter() + .find(|row| row.r#type == expected.r#type && row.key == expected.key) + != Some(&expected) + { + bail!("Repository Body changed while reconstructing workspace checkpoint chain"); + } + } Ok(reversed) } @@ -759,9 +772,11 @@ pub(crate) fn sign_workspace_coverage_projection_batch_checkpoint( } pub(crate) fn admit_workspace_coverage_projection_batch_checkpoint( - body_store: impl AsRef, + body_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, local_verse_store: impl AsRef, trusted_host: &HostIncarnationIdentityEntry, + provider_signing_key: &SigningKey, entry: WorkspaceCoverageProjectionBatchCheckpointEntry, ) -> Result { validate_shape(&entry, true)?; @@ -774,15 +789,27 @@ pub(crate) fn admit_workspace_coverage_projection_batch_checkpoint( trusted_host, )?; validate_launch(&entry, &launch, &launch_envelope_digest)?; - let backing = SingleFileMessagePackBackingStore::new(body_store.as_ref()); - let opening = backing.pull_all()?; - let binding_env = find(&opening, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; - let head_env = find(&opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; - let observation_env = find(&opening, BODY_OBSERVATION_TYPE, &entry.body_observation_id)?; - let manifest_env = find(&opening, BODY_MANIFEST_TYPE, &entry.manifest_root_sha256)?; + let opening = coverage_store.pull_all()?; + let body_opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + let binding_env = find(&body_opening, BODY_BINDING_TYPE, BODY_BINDING_KEY)?; + let head_env = find(&body_opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?; + let observation_env = find( + &body_opening, + BODY_OBSERVATION_TYPE, + &entry.body_observation_id, + )?; + let manifest_env = find( + &body_opening, + BODY_MANIFEST_TYPE, + &entry.manifest_root_sha256, + )?; let obligation_env = find(&opening, OBLIGATION_TYPE, &entry.obligation_id)?; let plan_env = find(&opening, PLAN_TYPE, &entry.plan_id)?; - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY)?; + let claim_env = find( + &opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&entry.body_observation_id, entry.body_generation), + )?; let attempt_env = find(&opening, ATTEMPT_TYPE, &entry.attempt_id)?; let binding: RepositoryBodyBinding = decode(binding_env)?; let body_head: RepositoryBodyHead = decode(head_env)?; @@ -796,7 +823,7 @@ pub(crate) fn admit_workspace_coverage_projection_batch_checkpoint( validate_projection_attempt(&attempt)?; validate_claim_attempt_link(&claim, &attempt)?; validate_workspace_coverage_projection_plan(&obligation, &plan)?; - exact_obligation_body_authority(&opening, &obligation)?; + let body_authority = exact_obligation_body_authority(&body_opening, &obligation)?; validate_authority( &entry, &binding, @@ -872,10 +899,6 @@ pub(crate) fn admit_workspace_coverage_projection_batch_checkpoint( collection_name: entry.collection_name.clone(), }; let authority = vec![ - binding_env.clone(), - head_env.clone(), - observation_env.clone(), - manifest_env.clone(), obligation_env.clone(), plan_env.clone(), claim_env.clone(), @@ -892,13 +915,36 @@ pub(crate) fn admit_workspace_coverage_projection_batch_checkpoint( } replacements.push(event_env); replacements.push(envelope(HEAD_TYPE, &head_key, &next_head)?); - if !backing.compare_and_swap_batch(&expected, replacements)? { - bail!("workspace coverage checkpoint lost exact Body/plan/claim/head compare-and-swap"); - } - Ok(WorkspaceCoverageProjectionBatchCheckpointAdmission { + let admission = WorkspaceCoverageProjectionBatchCheckpointAdmission { checkpoint: entry, checkpoint_envelope_digest: next_head.checkpoint_envelope_digest, - }) + }; + let (progress_expected, progress_replacements, progress) = + crate::workspace_coverage_projection_progress::prepare_workspace_coverage_progress_for_checkpoint( + coverage_store, + provider_signing_key, + &admission, + )?; + expected.extend(progress_expected); + replacements.extend(progress_replacements); + if !coverage_store.compare_and_swap_batch(&expected, replacements)? { + bail!("workspace coverage checkpoint lost exact coverage authority compare-and-swap"); + } + let closing_body = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + for expected in body_authority { + if closing_body + .iter() + .find(|row| row.r#type == expected.r#type && row.key == expected.key) + != Some(&expected) + { + bail!("Repository Body changed during workspace coverage checkpoint admission"); + } + } + debug_assert_eq!( + progress.completed_units, + admission.checkpoint.cumulative_point_count + ); + Ok(admission) } #[allow(clippy::too_many_arguments)] @@ -1235,6 +1281,17 @@ fn find<'a>(v: &'a [CultCacheEnvelope], t: &str, k: &str) -> Result<&'a CultCach .find(|e| e.r#type == t && e.key == k) .ok_or_else(|| anyhow!("missing authority envelope {t}/{k}")) } +fn find_current_claim<'a>( + coverage_opening: &'a [CultCacheEnvelope], + body_opening: &[CultCacheEnvelope], +) -> Result<&'a CultCacheEnvelope> { + let head: RepositoryBodyHead = decode(find(body_opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?)?; + find( + coverage_opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&head.observation_id, head.generation), + ) +} fn decode(e: &CultCacheEnvelope) -> Result { Ok(rmp_serde::from_slice(&e.payload)?) } diff --git a/epiphany-core/src/workspace_coverage_projection_progress.rs b/epiphany-core/src/workspace_coverage_projection_progress.rs index 1ea81ce1..f41ce91c 100644 --- a/epiphany-core/src/workspace_coverage_projection_progress.rs +++ b/epiphany-core/src/workspace_coverage_projection_progress.rs @@ -3,26 +3,25 @@ use crate::workspace_coverage_projection_batch_checkpoint::{ WorkspaceCoverageProjectionBatchCheckpointAdmission, load_authenticated_current_checkpoint, }; use crate::workspace_coverage_projector::{ - ATTEMPT_TYPE, CHUNKER_ID, CLAIM_KEY, CLAIM_TYPE, OBLIGATION_TYPE, PLAN_TYPE, PROJECTION_SCHEMA, + ATTEMPT_TYPE, CHUNKER_ID, CLAIM_TYPE, OBLIGATION_TYPE, PLAN_TYPE, PROJECTION_SCHEMA, WorkspaceCoverageProjectionAttempt, WorkspaceCoverageProjectionClaim, exact_obligation_body_authority, validate_claim_attempt_link, validate_projection_attempt, - validate_projection_claim, + validate_projection_claim, workspace_coverage_claim_key, }; use crate::workspace_retrieval_coverage::{ WorkspaceCoverageObligation, WorkspaceCoverageProjectionPlan, validate_workspace_coverage_projection_plan, }; use crate::{ - HostIncarnationIdentityEntry, WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES, - WorkspaceCoverageManagedProcessLaunchEntry, WorkspaceCoveragePolicy, - authenticate_workspace_coverage_managed_process_launch, - load_workspace_coverage_managed_process_launch_with_digest, open_epiphany_cultmesh_node, - runtime_repository_body_store_binding, + BODY_HEAD_KEY, BODY_HEAD_TYPE, HostIncarnationIdentityEntry, RepositoryBodyHead, + WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES, WorkspaceCoverageManagedProcessLaunchEntry, + WorkspaceCoveragePolicy, authenticate_workspace_coverage_managed_process_launch, }; use anyhow::{Context, Result, anyhow, bail}; use chrono::DateTime; use cultcache_rs::{ - CacheBackingStore, CultCacheEnvelope, DatabaseEntry, SingleFileMessagePackBackingStore, + CacheBackingStore, CultCacheEnvelope, DatabaseEntry, OwnedRedbMessagePackBackingStore, + SingleFileMessagePackBackingStore, }; use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey}; use serde::Serialize; @@ -204,7 +203,8 @@ pub(crate) fn sign_workspace_coverage_projection_progress( } pub(crate) fn publish_workspace_coverage_progress_genesis( - body_store: impl AsRef, + body_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, local_verse_store: impl AsRef, runtime_id: &str, trusted_host: &HostIncarnationIdentityEntry, @@ -214,8 +214,9 @@ pub(crate) fn publish_workspace_coverage_progress_genesis( if operation_timeout_ms == 0 { bail!("workspace coverage progress operation timeout must be positive"); } - let opening = SingleFileMessagePackBackingStore::new(body_store.as_ref()).pull_all()?; - let claim_env = find_authority(&opening, CLAIM_TYPE, CLAIM_KEY)?; + let opening = coverage_store.pull_all()?; + let body_opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + let claim_env = find_current_claim(&opening, &body_opening)?; let claim: WorkspaceCoverageProjectionClaim = rmp_serde::from_slice(&claim_env.payload)?; let attempt_env = find_authority(&opening, ATTEMPT_TYPE, &claim.attempt_id)?; let attempt: WorkspaceCoverageProjectionAttempt = rmp_serde::from_slice(&attempt_env.payload)?; @@ -230,7 +231,7 @@ pub(crate) fn publish_workspace_coverage_progress_genesis( let obligation: WorkspaceCoverageObligation = rmp_serde::from_slice(&obligation_env.payload)?; let plan: WorkspaceCoverageProjectionPlan = rmp_serde::from_slice(&plan_env.payload)?; validate_workspace_coverage_projection_plan(&obligation, &plan)?; - exact_obligation_body_authority(&opening, &obligation)?; + let body_authority = exact_obligation_body_authority(&body_opening, &obligation)?; let (launch, launch_digest) = authenticate_workspace_coverage_managed_process_launch_with_envelope_digest( local_verse_store.as_ref(), @@ -247,8 +248,7 @@ pub(crate) fn publish_workspace_coverage_progress_genesis( bail!("workspace coverage progress genesis signer/launch/Body authority disagrees"); } if load_latest_workspace_coverage_projection_progress( - local_verse_store.as_ref(), - runtime_id, + coverage_store, &launch.launch_id, &claim.claim_id, )? @@ -289,54 +289,44 @@ pub(crate) fn publish_workspace_coverage_progress_genesis( signature_algorithm: "ed25519".into(), }; sign_workspace_coverage_projection_progress(&mut entry, provider_signing_key)?; - let admitted = write_workspace_coverage_projection_progress( - local_verse_store.as_ref(), - runtime_id, - entry, - )?; - // Body and Verse are distinct stores and cannot share an atomic CAS. A - // progress event is therefore provider observation only. Reopen Body after - // Verse admission and require the exact authority envelopes used above; - // downstream use must repeat Body/checkpoint authentication rather than - // treating this event as a capability. - let after = SingleFileMessagePackBackingStore::new(body_store.as_ref()).pull_all()?; - for expected in [claim_env, attempt_env, obligation_env, plan_env] { - let current = find_authority(&after, &expected.r#type, &expected.key)?; - if current.r#type != expected.r#type - || current.key != expected.key - || current.payload != expected.payload + let published = write_workspace_coverage_projection_progress(coverage_store, entry)?; + let closing_body = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + for expected in body_authority { + if closing_body + .iter() + .find(|entry| entry.r#type == expected.r#type && entry.key == expected.key) + != Some(&expected) { - bail!("Body authority changed during cross-store progress genesis admission"); + bail!("Repository Body changed during workspace coverage progress genesis"); } } - exact_obligation_body_authority(&after, &obligation)?; - Ok(admitted) + Ok(published) } -pub(crate) fn publish_workspace_coverage_progress_for_checkpoint( - local_verse_store: impl AsRef, - runtime_id: &str, +pub(crate) fn prepare_workspace_coverage_progress_for_checkpoint( + coverage_store: &OwnedRedbMessagePackBackingStore, provider_signing_key: &SigningKey, admission: &WorkspaceCoverageProjectionBatchCheckpointAdmission, -) -> Result { +) -> Result<( + Vec, + Vec, + WorkspaceCoverageProjectionProgressEntry, +)> { let checkpoint = &admission.checkpoint; - if checkpoint.runtime_id != runtime_id { - bail!("checkpoint progress runtime disagrees with admission"); - } - let prior = load_latest_workspace_coverage_projection_progress( - local_verse_store.as_ref(), - runtime_id, - &checkpoint.managed_process_launch_id, - &checkpoint.claim_id, - )? - .ok_or_else(|| anyhow!("checkpoint progress requires canonical genesis"))?; + let prior_key = latest_key(&checkpoint.managed_process_launch_id, &checkpoint.claim_id); + let opening = coverage_store.pull_all()?; + let prior_env = opening + .iter() + .find(|env| { + env.r#type == WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE && env.key == prior_key + }) + .cloned() + .ok_or_else(|| anyhow!("checkpoint progress requires canonical genesis"))?; + let prior: WorkspaceCoverageProjectionProgressEntry = decode(&prior_env)?; let expected_sequence = checkpoint .sequence .checked_add(1) .ok_or_else(|| anyhow!("checkpoint sequence exhausted"))?; - if checkpoint_progress_alignment(&prior, admission)? == CheckpointProgressAlignment::Current { - return Ok(prior); - } if prior.sequence != checkpoint.sequence || checkpoint.cumulative_point_count <= prior.completed_units { @@ -346,7 +336,7 @@ pub(crate) fn publish_workspace_coverage_progress_for_checkpoint( let mut entry = WorkspaceCoverageProjectionProgressEntry { schema_version: WORKSPACE_COVERAGE_PROJECTION_PROGRESS_SCHEMA_VERSION.into(), progress_id: uuid::Uuid::new_v4().to_string(), - runtime_id: runtime_id.into(), + runtime_id: checkpoint.runtime_id.clone(), launch_id: checkpoint.managed_process_launch_id.clone(), launch_envelope_digest: checkpoint.managed_process_launch_envelope_digest.clone(), provider_incarnation_id: checkpoint.provider_incarnation_id.clone(), @@ -375,19 +365,22 @@ pub(crate) fn publish_workspace_coverage_progress_for_checkpoint( signature_algorithm: "ed25519".into(), }; sign_workspace_coverage_projection_progress(&mut entry, provider_signing_key)?; - write_workspace_coverage_projection_progress(local_verse_store, runtime_id, entry) -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum CheckpointProgressAlignment { - NeedsReconciliation, - Current, + validate_shape(&entry, true)?; + validate_transition(&prior, &entry)?; + let event_key = progress_key(&entry.progress_id); + let latest_key = latest_key(&entry.launch_id, &entry.claim_id); + let expected = vec![prior_env]; + let replacements = vec![ + progress_envelope(&event_key, &entry)?, + progress_envelope(&latest_key, &entry)?, + ]; + Ok((expected, replacements, entry)) } fn checkpoint_progress_alignment( progress: &WorkspaceCoverageProjectionProgressEntry, admission: &WorkspaceCoverageProjectionBatchCheckpointAdmission, -) -> Result { +) -> Result<()> { let checkpoint = &admission.checkpoint; checkpoint_progress_binding_alignment( progress, @@ -404,83 +397,43 @@ fn checkpoint_progress_binding_alignment( checkpoint_id: &str, checkpoint_digest: &str, cumulative_point_count: u64, -) -> Result { +) -> Result<()> { let expected = checkpoint_sequence .checked_add(1) .ok_or_else(|| anyhow!("checkpoint sequence exhausted"))?; - if progress.sequence == checkpoint_sequence { - return Ok(CheckpointProgressAlignment::NeedsReconciliation); - } if progress.sequence == expected && progress.checkpoint_id.as_deref() == Some(checkpoint_id) && progress.checkpoint_binding_sha256.as_deref() == Some(checkpoint_digest) && progress.completed_units == cumulative_point_count { - return Ok(CheckpointProgressAlignment::Current); + return Ok(()); } bail!("progress does not map exactly to the authenticated current checkpoint") } -pub(crate) fn reconcile_workspace_coverage_checkpoint_progress( - body_store: impl AsRef, - local_verse_store: impl AsRef, - runtime_id: &str, - trusted_host: &HostIncarnationIdentityEntry, - provider_signing_key: &SigningKey, - claim_id: &str, - claim_epoch: u64, -) -> Result> { - let Some(admission) = load_authenticated_current_checkpoint( - body_store, - local_verse_store.as_ref(), - trusted_host, - claim_id, - claim_epoch, - )? - else { - return Ok(None); - }; - if admission.checkpoint.runtime_id != runtime_id { - bail!("current checkpoint runtime disagrees with reconciliation runtime"); - } - publish_workspace_coverage_progress_for_checkpoint( - local_verse_store, - runtime_id, - provider_signing_key, - &admission, - ) - .map(Some) -} - pub(crate) fn write_workspace_coverage_projection_progress( - store_path: impl AsRef, - runtime_id: impl Into, + store: &OwnedRedbMessagePackBackingStore, entry: WorkspaceCoverageProjectionProgressEntry, ) -> Result { validate_shape(&entry, true)?; - let runtime_id = runtime_id.into(); - if runtime_id != entry.runtime_id { - bail!("workspace coverage progress runtime argument disagrees with signed runtime id"); - } - let store_path = store_path.as_ref(); - let (launch, launch_digest) = load_workspace_coverage_managed_process_launch_with_digest( - store_path, - runtime_id.clone(), - &entry.launch_id, - )? - .ok_or_else(|| anyhow!("workspace coverage progress launch is absent"))?; - authenticate_against_launch(&entry, &launch, &launch_digest)?; - let node = open_epiphany_cultmesh_node(store_path, runtime_id)?; + verify_signature(&entry)?; + let opening = store.pull_all()?; let event_key = progress_key(&entry.progress_id); - if let Some(existing) = node.get::(&event_key)? { + if let Some(existing_env) = opening.iter().find(|env| { + env.r#type == WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE && env.key == event_key + }) { + let existing: WorkspaceCoverageProjectionProgressEntry = decode(existing_env)?; if existing_event_is_idempotent(&existing, &entry)? { return Ok(existing); } } let latest_key = latest_key(&entry.launch_id, &entry.claim_id); - let latest = node - .cache() - .get_envelope::(&latest_key)?; + let latest = opening + .iter() + .find(|env| { + env.r#type == WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE && env.key == latest_key + }) + .cloned(); let mut expected = Vec::new(); if let Some(envelope) = latest.as_ref() { let prior: WorkspaceCoverageProjectionProgressEntry = @@ -491,62 +444,54 @@ pub(crate) fn write_workspace_coverage_projection_progress( bail!("first workspace coverage progress sequence must be one"); } let replacements = vec![ - node.cache().prepare_entry(&event_key, &entry)?.0, - node.cache().prepare_entry(&latest_key, &entry)?.0, + progress_envelope(&event_key, &entry)?, + progress_envelope(&latest_key, &entry)?, ]; - if !SingleFileMessagePackBackingStore::new(store_path) - .compare_and_swap_batch(&expected, replacements)? - { + if !store.compare_and_swap_batch(&expected, replacements)? { bail!("workspace coverage progress lost exact launch/claim latest compare-and-swap"); } Ok(entry) } pub fn load_workspace_coverage_projection_progress( - store_path: impl AsRef, - runtime_id: impl Into, + store: &OwnedRedbMessagePackBackingStore, progress_id: &str, ) -> Result> { require("progress id", progress_id)?; - open_epiphany_cultmesh_node(store_path, runtime_id)?.get(&progress_key(progress_id)) + load_progress(store, &progress_key(progress_id)) } pub fn load_latest_workspace_coverage_projection_progress( - store_path: impl AsRef, - runtime_id: impl Into, + store: &OwnedRedbMessagePackBackingStore, launch_id: &str, claim_id: &str, ) -> Result> { require("launch id", launch_id)?; require("claim id", claim_id)?; - open_epiphany_cultmesh_node(store_path, runtime_id)?.get(&latest_key(launch_id, claim_id)) + load_progress(store, &latest_key(launch_id, claim_id)) } pub fn authenticate_workspace_coverage_projection_progress( - store_path: impl AsRef, - runtime_id: impl Into, + store: &OwnedRedbMessagePackBackingStore, + local_verse_store: impl AsRef, + runtime_id: &str, progress_id: &str, host: &HostIncarnationIdentityEntry, ) -> Result { - let runtime_id = runtime_id.into(); - let entry = load_workspace_coverage_projection_progress( - store_path.as_ref(), - runtime_id.clone(), - progress_id, - )? - .ok_or_else(|| anyhow!("workspace coverage progress is absent"))?; + let entry = load_workspace_coverage_projection_progress(store, progress_id)? + .ok_or_else(|| anyhow!("workspace coverage progress is absent"))?; let launch = authenticate_workspace_coverage_managed_process_launch( - store_path.as_ref(), - runtime_id.clone(), + local_verse_store.as_ref(), + runtime_id, &entry.launch_id, host, )?; - let (_, digest) = load_workspace_coverage_managed_process_launch_with_digest( - store_path.as_ref(), - runtime_id.clone(), + let (_, digest) = authenticate_workspace_coverage_managed_process_launch_with_envelope_digest( + local_verse_store.as_ref(), + runtime_id, &entry.launch_id, - )? - .ok_or_else(|| anyhow!("workspace coverage progress launch is absent"))?; + host, + )?; authenticate_against_launch(&entry, &launch, &digest)?; Ok(entry) } @@ -556,7 +501,8 @@ pub fn authenticate_workspace_coverage_projection_progress( /// consulted here. The supervisor separately joins this evidence to the exact /// live managed process and applies its own no-advance lease. pub fn authenticate_current_workspace_coverage_advancement( - runtime_store: impl AsRef, + body_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, local_verse_store: impl AsRef, runtime_id: &str, launch_id: &str, @@ -567,11 +513,10 @@ pub fn authenticate_current_workspace_coverage_advancement( if no_advance_lease <= chrono::Duration::zero() { bail!("workspace coverage no-advance lease must be positive"); } - let route = runtime_repository_body_store_binding(runtime_store.as_ref())? - .ok_or_else(|| anyhow!("runtime has no repository Body-store binding"))?; - let opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; + let opening = coverage_store.pull_all()?; + let body_opening = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; let claim: WorkspaceCoverageProjectionClaim = - decode(find_authority(&opening, CLAIM_TYPE, CLAIM_KEY)?)?; + decode(find_current_claim(&opening, &body_opening)?)?; validate_projection_claim(&claim)?; let attempt: WorkspaceCoverageProjectionAttempt = decode(find_authority(&opening, ATTEMPT_TYPE, &claim.attempt_id)?)?; @@ -588,7 +533,7 @@ pub fn authenticate_current_workspace_coverage_advancement( let plan: WorkspaceCoverageProjectionPlan = decode(find_authority(&opening, PLAN_TYPE, &claim.plan_id)?)?; validate_workspace_coverage_projection_plan(&obligation, &plan)?; - exact_obligation_body_authority(&opening, &obligation)?; + let body_authority = exact_obligation_body_authority(&body_opening, &obligation)?; let policy = WorkspaceCoveragePolicy::bounded_regular_files_v0(WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES)?; let policy_sha256 = format!( @@ -604,8 +549,7 @@ pub fn authenticate_current_workspace_coverage_advancement( } let Some(latest) = load_latest_workspace_coverage_projection_progress( - local_verse_store.as_ref(), - runtime_id, + coverage_store, launch_id, &claim.claim_id, )? @@ -613,6 +557,7 @@ pub fn authenticate_current_workspace_coverage_advancement( return Ok(None); }; let progress = authenticate_workspace_coverage_projection_progress( + coverage_store, local_verse_store.as_ref(), runtime_id, &latest.progress_id, @@ -631,7 +576,8 @@ pub fn authenticate_current_workspace_coverage_advancement( return Ok(None); } let Some(checkpoint) = load_authenticated_current_checkpoint( - &route.body_store_path, + body_store, + coverage_store, local_verse_store.as_ref(), host, &claim.claim_id, @@ -640,11 +586,7 @@ pub fn authenticate_current_workspace_coverage_advancement( else { return Ok(None); }; - if checkpoint_progress_alignment(&progress, &checkpoint)? - != CheckpointProgressAlignment::Current - { - return Ok(None); - } + checkpoint_progress_alignment(&progress, &checkpoint)?; if !progress_is_within_no_advance_lease( &progress.last_advanced_at_utc, observed_at, @@ -652,7 +594,7 @@ pub fn authenticate_current_workspace_coverage_advancement( )? { return Ok(None); } - Ok(Some(WorkspaceCoverageAdvancingAuthority { + let authority = WorkspaceCoverageAdvancingAuthority { progress_id: progress.progress_id, checkpoint_id: checkpoint.checkpoint.checkpoint_id, checkpoint_binding_sha256: checkpoint.checkpoint_envelope_digest, @@ -662,7 +604,18 @@ pub fn authenticate_current_workspace_coverage_advancement( completed_units: progress.completed_units, total_units: progress.total_units, last_advanced_at_utc: progress.last_advanced_at_utc, - })) + }; + let closing_body = SingleFileMessagePackBackingStore::new(body_store).pull_all()?; + for expected in body_authority { + if closing_body + .iter() + .find(|row| row.r#type == expected.r#type && row.key == expected.key) + != Some(&expected) + { + bail!("Repository Body changed while authenticating workspace advancement"); + } + } + Ok(Some(authority)) } fn progress_is_within_no_advance_lease( @@ -924,12 +877,47 @@ fn find_authority<'a>( .find(|entry| entry.r#type == ty && entry.key == key) .ok_or_else(|| anyhow!("workspace coverage progress authority {ty}/{key} is absent")) } +fn find_current_claim<'a>( + coverage_opening: &'a [CultCacheEnvelope], + body_opening: &[CultCacheEnvelope], +) -> Result<&'a CultCacheEnvelope> { + let head: RepositoryBodyHead = + decode(find_authority(body_opening, BODY_HEAD_TYPE, BODY_HEAD_KEY)?)?; + find_authority( + coverage_opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&head.observation_id, head.generation), + ) +} fn decode(entry: &CultCacheEnvelope) -> Result { rmp_serde::from_slice(&entry.payload).context("decoding workspace coverage progress authority") } fn progress_key(id: &str) -> String { format!("epiphany-local/workspace-coverage/projection-progress/event/{id}") } +fn progress_envelope( + key: &str, + entry: &WorkspaceCoverageProjectionProgressEntry, +) -> Result { + Ok(CultCacheEnvelope { + r#type: WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE.into(), + key: key.into(), + payload: rmp_serde::to_vec(entry)?, + stored_at: chrono::Utc::now().to_rfc3339(), + schema_id: Some(WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE.into()), + }) +} +fn load_progress( + store: &OwnedRedbMessagePackBackingStore, + key: &str, +) -> Result> { + store + .pull_all()? + .iter() + .find(|env| env.r#type == WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE && env.key == key) + .map(decode) + .transpose() +} fn latest_key(launch: &str, claim: &str) -> String { format!("epiphany-local/workspace-coverage/projection-progress/latest/{launch}/{claim}") } @@ -1030,10 +1018,10 @@ mod tests { } } #[test] - fn checkpoint_progress_restart_mapping_is_exact_and_idempotent() { + fn checkpoint_progress_mapping_rejects_every_split_state() { let k = SigningKey::from_bytes(&[7; 32]); let genesis = entry(&k); - assert_eq!( + assert!( checkpoint_progress_binding_alignment( &genesis, 1, @@ -1041,20 +1029,15 @@ mod tests { &format!("sha256-{}", "b".repeat(64)), 1 ) - .unwrap(), - CheckpointProgressAlignment::NeedsReconciliation + .is_err() ); let current = advance(&genesis, &k); let digest = current.checkpoint_binding_sha256.clone().unwrap(); let id = current.checkpoint_id.clone().unwrap(); - assert_eq!( - checkpoint_progress_binding_alignment(¤t, 1, &id, &digest, 1).unwrap(), - CheckpointProgressAlignment::Current - ); - assert_eq!( + checkpoint_progress_binding_alignment(¤t, 1, &id, &digest, 1).unwrap(); + assert!( checkpoint_progress_binding_alignment(¤t, 2, "next-checkpoint", &digest, 2) - .unwrap(), - CheckpointProgressAlignment::NeedsReconciliation + .is_err() ); let mut skipped = current.clone(); skipped.sequence = 3; diff --git a/epiphany-core/src/workspace_coverage_projector.rs b/epiphany-core/src/workspace_coverage_projector.rs index 540932b9..cedc159c 100644 --- a/epiphany-core/src/workspace_coverage_projector.rs +++ b/epiphany-core/src/workspace_coverage_projector.rs @@ -1,17 +1,22 @@ use crate::repository_body_observer::RepositoryBodyReadSession; +#[cfg(test)] +use crate::semantic_backend::QDRANT_POINT_BATCH_MAX; use crate::semantic_backend::{ - CollectionCompatibility, OllamaEmbedder, QDRANT_POINT_BATCH_MAX, QdrantBackend, SemanticPoint, - SemanticStoredPoint, + CollectionCompatibility, OllamaEmbedder, QdrantBackend, SemanticPoint, SemanticStoredPoint, +}; +use crate::workspace_coverage_process_documents::{ + publish_workspace_coverage_advancement_sight, publish_workspace_coverage_terminal_sight, }; use crate::workspace_coverage_projection_batch_checkpoint::{ ObservedWorkspaceCoverageBatchInput, WorkspaceCoverageProjectionBatchCheckpointAdmission, - admit_observed_workspace_coverage_batch, load_authenticated_checkpoint_chain, + WorkspaceCoverageProjectionBatchCheckpointEntry, + WorkspaceCoverageProjectionBatchCheckpointHeadEntry, admit_observed_workspace_coverage_batch, + load_authenticated_checkpoint_chain, }; use crate::workspace_coverage_projection_progress::{ authenticate_workspace_coverage_projection_progress, load_latest_workspace_coverage_projection_progress, - publish_workspace_coverage_progress_for_checkpoint, - publish_workspace_coverage_progress_genesis, reconcile_workspace_coverage_checkpoint_progress, + publish_workspace_coverage_progress_genesis, }; use crate::{ BODY_BINDING_KEY, BODY_BINDING_TYPE, BODY_HEAD_KEY, BODY_HEAD_TYPE, BODY_MANIFEST_TYPE, @@ -34,7 +39,8 @@ use crate::{ }; use anyhow::{Context, Result, anyhow, bail}; use cultcache_rs::{ - CacheBackingStore, CultCacheEnvelope, DatabaseEntry, SingleFileMessagePackBackingStore, + CacheBackingStore, CultCacheEnvelope, DatabaseEntry, OwnedRedbMessagePackBackingStore, + SingleFileMessagePackBackingStore, }; use ed25519_dalek::SigningKey; use serde::Serialize; @@ -47,7 +53,6 @@ pub(crate) const ATTEMPT_TYPE: &str = "gamecult.epiphany.workspace_coverage_proj /// transport ceiling. On the deployment baseline this bounds checkpoint loss /// to a few minutes while retaining waited, exact batch writes. const WORKSPACE_COVERAGE_CHECKPOINT_BATCH_POINTS: usize = 1; -pub(crate) const CLAIM_KEY: &str = "workspace-coverage-projector-current"; const CLAIM_SCHEMA: &str = "gamecult.epiphany.workspace_coverage_projection_claim.v1"; const ATTEMPT_SCHEMA: &str = "gamecult.epiphany.workspace_coverage_projection_attempt.v1"; const CLAIM_SCHEMA_V2: &str = "gamecult.epiphany.workspace_coverage_projection_claim.v2"; @@ -65,6 +70,13 @@ const CHUNK_MAX_BYTES: usize = 12 * 1024; const RECEIPT_TYPE: &str = "gamecult.epiphany.workspace_coverage_receipt"; const HEAD_TYPE: &str = "gamecult.epiphany.workspace_coverage_head"; const HEAD_KEY: &str = "current"; +const RETENTION_HEAD_TYPE: &str = "gamecult.epiphany.workspace_coverage_retention_head"; +const RETENTION_HEAD_KEY: &str = "current"; +const RETENTION_HEAD_SCHEMA: &str = "gamecult.epiphany.workspace_coverage_retention_head.v0"; +pub(crate) const COLLECTION_RETIREMENT_EVIDENCE_TYPE: &str = + "gamecult.epiphany.workspace_coverage_collection_retirement_evidence"; +const COLLECTION_RETIREMENT_EVIDENCE_SCHEMA: &str = + "gamecult.epiphany.workspace_coverage_collection_retirement_evidence.v0"; pub(crate) const OBLIGATION_TYPE: &str = "gamecult.epiphany.workspace_coverage_obligation"; pub(crate) const PLAN_TYPE: &str = "gamecult.epiphany.workspace_coverage_projection_plan"; @@ -77,6 +89,8 @@ struct WorkspaceCoverageProjectionInput { } pub(crate) struct WorkspaceCoverageProjectionExecutionAuthority<'a> { + pub coverage_authority: &'a crate::WorkspaceCoverageAuthority, + pub runtime_store: &'a Path, pub local_verse_store: &'a Path, pub runtime_id: &'a str, pub trusted_host: &'a HostIncarnationIdentityEntry, @@ -153,6 +167,608 @@ pub(crate) trait WorkspaceCoverageEvidencePort { pub(crate) struct WorkspaceCoverageRetirementCandidate { pub collection_name: String, pub compatibility: CollectionCompatibility, + pub claim_id: String, + pub attempt_id: String, + pub plan_id: String, + pub body_observation_id: String, + pub body_generation: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "gamecult.epiphany.workspace_coverage_collection_retirement_evidence", + schema = "WorkspaceCoverageCollectionRetirementEvidence" +)] +pub(crate) struct WorkspaceCoverageCollectionRetirementEvidence { + #[cultcache(key = 0)] + pub schema_version: String, + #[cultcache(key = 1)] + pub collection_name: String, + #[cultcache(key = 2)] + pub collection_compatibility_sha256: String, + #[cultcache(key = 3)] + pub claim_id: String, + #[cultcache(key = 4)] + pub attempt_id: String, + #[cultcache(key = 5)] + pub plan_id: String, + #[cultcache(key = 6)] + pub body_observation_id: String, + #[cultcache(key = 7)] + pub body_generation: u64, + #[cultcache(key = 8)] + pub runtime_id: String, + #[cultcache(key = 9)] + pub workspace_id: String, + #[cultcache(key = 10)] + pub coverage_binding_id: String, + #[cultcache(key = 11)] + pub coverage_binding_envelope_sha256: String, + #[cultcache(key = 12)] + pub coverage_store_file_identity: String, + #[cultcache(key = 13)] + pub observed_result: String, + #[cultcache(key = 14)] + pub observed_at_utc: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "gamecult.epiphany.workspace_coverage_retention_head", + schema = "WorkspaceCoverageRetentionHead" +)] +pub(crate) struct WorkspaceCoverageRetentionHead { + #[cultcache(key = 0)] + pub schema_version: String, + #[cultcache(key = 1)] + pub sequence: u64, + #[cultcache(key = 2)] + pub prior_head_envelope_sha256: Option, + #[cultcache(key = 3)] + pub runtime_id: String, + #[cultcache(key = 4)] + pub workspace_id: String, + #[cultcache(key = 5)] + pub coverage_binding_id: String, + #[cultcache(key = 6)] + pub coverage_binding_envelope_sha256: String, + #[cultcache(key = 7)] + pub coverage_store_file_identity: String, + #[cultcache(key = 8)] + pub retired_envelope_count: u64, + #[cultcache(key = 9)] + pub retired_identity_digest_root: String, + #[cultcache(key = 10)] + pub family_counts: Vec, + #[cultcache(key = 11)] + pub family_digest_roots: Vec, + #[cultcache(key = 12)] + pub compacted_body_evidence_root: String, + #[cultcache(key = 13)] + pub compacted_plan_evidence_root: String, + #[cultcache(key = 14)] + pub compacted_claim_evidence_root: String, + #[cultcache(key = 15)] + pub compacted_receipt_evidence_root: String, + #[cultcache(key = 16)] + pub compacted_collection_retirement_evidence_root: String, + #[cultcache(key = 17)] + pub compacted_through_body_generation: u64, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum WorkspaceCoverageRetentionResult { + Noop, + Compacted, + HistoricalBodyMovement, +} + +fn is_sha256_digest(value: &str) -> bool { + let hex = value.strip_prefix("sha256-").unwrap_or(value); + hex.len() == 64 && hex.bytes().all(|byte| byte.is_ascii_hexdigit()) +} + +fn fold_digest(domain: &str, prior: &str, values: impl IntoIterator) -> String { + let mut values = values.into_iter().collect::>(); + values.sort(); + let mut hasher = Sha256::new(); + hasher.update(domain.as_bytes()); + hasher.update([0]); + hasher.update(prior.as_bytes()); + for value in values { + hasher.update([0]); + hasher.update(value.as_bytes()); + } + format!("sha256-{:x}", hasher.finalize()) +} + +fn validate_collection_retirement_evidence( + evidence: &WorkspaceCoverageCollectionRetirementEvidence, +) -> Result<()> { + if evidence.schema_version != COLLECTION_RETIREMENT_EVIDENCE_SCHEMA + || evidence.observed_result != "retired-or-absent" + || evidence.collection_name.trim().is_empty() + || evidence.claim_id.trim().is_empty() + || evidence.attempt_id.trim().is_empty() + || evidence.plan_id.trim().is_empty() + || evidence.body_observation_id.trim().is_empty() + || evidence.runtime_id.trim().is_empty() + || evidence.workspace_id.trim().is_empty() + || evidence.coverage_binding_id.trim().is_empty() + || evidence.coverage_store_file_identity.trim().is_empty() + || !is_sha256_digest(&evidence.collection_compatibility_sha256) + || !is_sha256_digest(&evidence.coverage_binding_envelope_sha256) + { + bail!("invalid workspace coverage collection-retirement evidence"); + } + chrono::DateTime::parse_from_rfc3339(&evidence.observed_at_utc)?; + Ok(()) +} + +fn parse_retention_family_values( + values: &[String], + kind: &str, +) -> Result> { + let mut parsed = std::collections::BTreeMap::new(); + for encoded in values { + let (ty, value) = encoded + .rsplit_once('=') + .ok_or_else(|| anyhow!("invalid retention family {kind}"))?; + if ty.trim().is_empty() + || value.trim().is_empty() + || parsed.insert(ty.into(), value.into()).is_some() + { + bail!("duplicate or empty retention family {kind}"); + } + } + Ok(parsed) +} + +fn validate_retention_head( + head: &WorkspaceCoverageRetentionHead, + authority: &crate::WorkspaceCoverageAuthority, +) -> Result<()> { + let counts = parse_retention_family_values(&head.family_counts, "count")?; + let roots = parse_retention_family_values(&head.family_digest_roots, "root")?; + let count_keys = counts.keys().collect::>(); + let root_keys = roots.keys().collect::>(); + let mut count_total = 0u64; + for count in counts.values() { + count_total = count_total + .checked_add(count.parse::()?) + .ok_or_else(|| anyhow!("retention family count overflow"))?; + } + if head.schema_version != RETENTION_HEAD_SCHEMA + || head.sequence == 0 + || (head.sequence == 1) != head.prior_head_envelope_sha256.is_none() + || head + .prior_head_envelope_sha256 + .as_deref() + .is_some_and(|digest| !is_sha256_digest(digest)) + || head.runtime_id != authority.store_binding.runtime_id + || head.workspace_id != authority.store_binding.workspace_id + || head.coverage_binding_id != authority.store_binding.binding_id + || head.coverage_binding_envelope_sha256 != authority.store_binding_envelope_sha256 + || head.coverage_store_file_identity != authority.store.file_identity() + || head.retired_envelope_count == 0 + || count_total != head.retired_envelope_count + || count_keys != root_keys + || roots.values().any(|root| !is_sha256_digest(root)) + || !is_sha256_digest(&head.retired_identity_digest_root) + || !is_sha256_digest(&head.compacted_body_evidence_root) + || !is_sha256_digest(&head.compacted_plan_evidence_root) + || !is_sha256_digest(&head.compacted_claim_evidence_root) + || !is_sha256_digest(&head.compacted_receipt_evidence_root) + || !is_sha256_digest(&head.compacted_collection_retirement_evidence_root) + { + bail!("invalid or forked workspace coverage retention accumulator"); + } + Ok(()) +} + +fn retention_allowed_type(ty: &str) -> bool { + matches!( + ty, + "gamecult.epiphany.workspace_coverage_store_binding" + | OBLIGATION_TYPE + | PLAN_TYPE + | CLAIM_TYPE + | ATTEMPT_TYPE + | RECEIPT_TYPE + | HEAD_TYPE + | RECOVERY_TYPE + | COLLECTION_RETIREMENT_EVIDENCE_TYPE + | RETENTION_HEAD_TYPE + | crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_TYPE + | crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_HEAD_TYPE + | crate::workspace_coverage_projection_progress::WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE + ) +} + +fn validate_retention_opening_rows( + opening: &[CultCacheEnvelope], + authority: &crate::WorkspaceCoverageAuthority, +) -> Result<()> { + for entry in opening { + match entry.r#type.as_str() { + "gamecult.epiphany.workspace_coverage_store_binding" => { + let _: crate::WorkspaceCoverageStoreBinding = decode(entry)?; + } + OBLIGATION_TYPE => { + let value: WorkspaceCoverageObligation = decode(entry)?; + if value.obligation_id.trim().is_empty() || value.body_generation == 0 { + bail!("invalid retained workspace coverage obligation"); + } + } + PLAN_TYPE => { + let value: WorkspaceCoverageProjectionPlan = decode(entry)?; + if value.plan_id.trim().is_empty() || value.obligation_id.trim().is_empty() { + bail!("invalid retained workspace coverage plan"); + } + } + CLAIM_TYPE => validate_projection_claim(&decode(entry)?)?, + ATTEMPT_TYPE => validate_projection_attempt(&decode(entry)?)?, + RECEIPT_TYPE => { + let value: WorkspaceCoverageReceipt = decode(entry)?; + if value.receipt_id.trim().is_empty() || value.claim_id.trim().is_empty() { + bail!("invalid retained workspace coverage receipt"); + } + } + HEAD_TYPE => { + let _: WorkspaceCoverageHead = decode(entry)?; + } + RECOVERY_TYPE => validate_recovery_receipt(&decode(entry)?)?, + COLLECTION_RETIREMENT_EVIDENCE_TYPE => { + validate_collection_retirement_evidence(&decode(entry)?)? + } + RETENTION_HEAD_TYPE => validate_retention_head(&decode(entry)?, authority)?, + crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_TYPE => { + let _: WorkspaceCoverageProjectionBatchCheckpointEntry = decode(entry)?; + } + crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_HEAD_TYPE => { + let _: WorkspaceCoverageProjectionBatchCheckpointHeadEntry = decode(entry)?; + } + crate::workspace_coverage_projection_progress::WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE => { + let _: crate::workspace_coverage_projection_progress::WorkspaceCoverageProjectionProgressEntry = decode(entry)?; + } + _ => bail!("workspace coverage retention refuses unknown type {}", entry.r#type), + } + } + Ok(()) +} + +/// Compacts only generations made unreachable by a newer terminal head. The +/// singleton accumulator is historical evidence and is never consulted by +/// current/readiness/recovery paths. +pub(crate) fn compact_workspace_coverage_history( + runtime_store: &Path, + authority: &crate::WorkspaceCoverageAuthority, +) -> Result { + let body_before = crate::load_current_runtime_repository_body_basis(runtime_store)?; + let opening = authority.store.pull_all()?; + if let Some(unknown) = opening + .iter() + .find(|entry| !retention_allowed_type(&entry.r#type)) + { + bail!( + "workspace coverage retention refuses unknown type {}", + unknown.r#type + ); + } + validate_retention_opening_rows(&opening, authority)?; + let Some(current_head_env) = find(&opening, HEAD_TYPE, HEAD_KEY) else { + return Ok(WorkspaceCoverageRetentionResult::Noop); + }; + let current_head: WorkspaceCoverageHead = decode(current_head_env)?; + if current_head.body_generation != body_before.generation + || current_head.body_observation_id != body_before.observation_id + { + return Ok(WorkspaceCoverageRetentionResult::HistoricalBodyMovement); + } + let preserve_from = current_head.body_generation.saturating_sub(1); + let claims = opening + .iter() + .filter(|entry| entry.r#type == CLAIM_TYPE) + .map(|entry| Ok((entry, decode::(entry)?))) + .collect::>>()?; + let active_generations = claims + .iter() + .filter(|(_, claim)| claim.status == "running") + .map(|(_, claim)| claim.body_generation) + .collect::>(); + let eligible_claims = claims + .iter() + .filter(|(_, claim)| { + claim.body_generation < preserve_from + && claim.status != "running" + && !active_generations.contains(&claim.body_generation) + }) + .map(|(_, claim)| claim.claim_id.clone()) + .collect::>(); + if eligible_claims.is_empty() { + return Ok(WorkspaceCoverageRetentionResult::Noop); + } + let eligible_generations = claims + .iter() + .filter(|(_, claim)| eligible_claims.contains(&claim.claim_id)) + .map(|(_, claim)| claim.body_generation) + .collect::>(); + let eligible_obligations = opening + .iter() + .filter(|entry| entry.r#type == OBLIGATION_TYPE) + .filter_map(|entry| { + decode::(entry) + .ok() + .map(|value| (entry, value)) + }) + .filter(|(_, value)| eligible_generations.contains(&value.body_generation)) + .map(|(entry, value)| (entry.clone(), value.obligation_id)) + .collect::>(); + let obligation_ids = eligible_obligations + .iter() + .map(|(_, id)| id.clone()) + .collect::>(); + let eligible_plans = opening + .iter() + .filter(|entry| entry.r#type == PLAN_TYPE) + .filter_map(|entry| { + decode::(entry) + .ok() + .map(|value| (entry, value)) + }) + .filter(|(_, value)| obligation_ids.contains(&value.obligation_id)) + .map(|(entry, value)| (entry.clone(), value.plan_id)) + .collect::>(); + let mut deletions = opening + .iter() + .filter(|entry| match entry.r#type.as_str() { + CLAIM_TYPE => decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + ATTEMPT_TYPE => decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + RECEIPT_TYPE => decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + RECOVERY_TYPE => decode::(entry).is_ok_and(|value| { + eligible_claims.contains(&value.old_claim_id) + && eligible_claims.contains(&value.new_claim_id) + }), + COLLECTION_RETIREMENT_EVIDENCE_TYPE => + decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_TYPE => + decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + crate::workspace_coverage_projection_batch_checkpoint::WORKSPACE_COVERAGE_PROJECTION_BATCH_CHECKPOINT_HEAD_TYPE => + decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + crate::workspace_coverage_projection_progress::WORKSPACE_COVERAGE_PROJECTION_PROGRESS_TYPE => + decode::(entry) + .is_ok_and(|value| eligible_claims.contains(&value.claim_id)), + _ => false, + }) + .cloned() + .collect::>(); + deletions.extend(eligible_obligations.iter().map(|(entry, _)| entry.clone())); + deletions.extend(eligible_plans.iter().map(|(entry, _)| entry.clone())); + for claim_id in &eligible_claims { + let attempts = opening + .iter() + .filter(|entry| entry.r#type == ATTEMPT_TYPE) + .map(decode::) + .collect::>>()? + .into_iter() + .filter(|attempt| &attempt.claim_id == claim_id); + for attempt in attempts { + let plan: WorkspaceCoverageProjectionPlan = decode( + find(&opening, PLAN_TYPE, &attempt.plan_id) + .ok_or_else(|| anyhow!("retired attempt lost its exact plan"))?, + )?; + let obligation: WorkspaceCoverageObligation = decode( + find(&opening, OBLIGATION_TYPE, &plan.obligation_id) + .ok_or_else(|| anyhow!("retired plan lost its exact obligation"))?, + )?; + let expected_collection = workspace_coverage_execution_collection( + &plan.plan_id, + claim_id, + attempt.claim_epoch, + )?; + let expected_compatibility = format!( + "sha256-{:x}", + Sha256::digest(rmp_serde::to_vec_named(&collection_compatibility(&plan))?) + ); + let evidence = opening + .iter() + .filter(|entry| entry.r#type == COLLECTION_RETIREMENT_EVIDENCE_TYPE) + .map(|entry| decode::(entry)) + .collect::>>()? + .into_iter() + .find(|value| { + value.claim_id == *claim_id && value.attempt_id == attempt.attempt_id + }); + let Some(evidence) = evidence else { + return Ok(WorkspaceCoverageRetentionResult::Noop); + }; + validate_collection_retirement_evidence(&evidence)?; + if evidence.collection_name != expected_collection + || evidence.collection_compatibility_sha256 != expected_compatibility + || evidence.plan_id != plan.plan_id + || evidence.body_observation_id != obligation.body_observation_id + || evidence.body_generation != obligation.body_generation + || evidence.runtime_id != authority.store_binding.runtime_id + || evidence.workspace_id != authority.store_binding.workspace_id + || evidence.coverage_binding_id != authority.store_binding.binding_id + || evidence.coverage_binding_envelope_sha256 + != authority.store_binding_envelope_sha256 + || evidence.coverage_store_file_identity != authority.store.file_identity() + { + bail!( + "workspace coverage retirement evidence disagrees with exact retired authority" + ); + } + } + } + deletions.sort_by(|left, right| (&left.r#type, &left.key).cmp(&(&right.r#type, &right.key))); + deletions.dedup_by(|left, right| left.r#type == right.r#type && left.key == right.key); + if deletions.is_empty() { + return Ok(WorkspaceCoverageRetentionResult::Noop); + } + let prior_env = find(&opening, RETENTION_HEAD_TYPE, RETENTION_HEAD_KEY).cloned(); + let prior = prior_env + .as_ref() + .map(decode::) + .transpose()?; + if let Some(prior) = &prior { + validate_retention_head(prior, authority)?; + if prior.compacted_through_body_generation > current_head.body_generation { + bail!("retention accumulator frontier exceeds current terminal Body generation"); + } + } + let retired_frontier = *eligible_generations.iter().max().unwrap_or(&0); + if retired_frontier > current_head.body_generation + || prior + .as_ref() + .is_some_and(|value| retired_frontier < value.compacted_through_body_generation) + { + bail!("retention compaction frontier is non-monotonic or exceeds current terminal"); + } + let envelope_digests = deletions + .iter() + .map(|entry| { + format!( + "{}:{}:{}", + entry.r#type, + entry.key, + cultcache_envelope_digest(entry) + ) + }) + .collect::>(); + let family = |ty: &str| { + deletions + .iter() + .filter(|entry| entry.r#type == ty) + .map(cultcache_envelope_digest) + .collect::>() + }; + let mut families = std::collections::BTreeMap::>::new(); + for entry in &deletions { + families + .entry(entry.r#type.clone()) + .or_default() + .push(cultcache_envelope_digest(entry)); + } + let mut family_counts = std::collections::BTreeMap::::new(); + let mut family_roots = std::collections::BTreeMap::::new(); + if let Some(prior) = &prior { + for encoded in &prior.family_counts { + let (ty, count) = encoded + .rsplit_once('=') + .ok_or_else(|| anyhow!("invalid retention family count"))?; + family_counts.insert(ty.into(), count.parse()?); + } + for encoded in &prior.family_digest_roots { + let (ty, root) = encoded + .rsplit_once('=') + .ok_or_else(|| anyhow!("invalid retention family root"))?; + family_roots.insert(ty.into(), root.into()); + } + } + for (ty, values) in &families { + *family_counts.entry(ty.clone()).or_default() += values.len() as u64; + let prior_family_root = family_roots.get(ty).map_or("", String::as_str); + family_roots.insert( + ty.clone(), + fold_digest( + "workspace-coverage-retention-family-v0", + prior_family_root, + values.clone(), + ), + ); + } + let prior_root = prior + .as_ref() + .map_or("", |value| value.retired_identity_digest_root.as_str()); + let head = WorkspaceCoverageRetentionHead { + schema_version: RETENTION_HEAD_SCHEMA.into(), + sequence: prior.as_ref().map_or(Ok(1), |value| { + value + .sequence + .checked_add(1) + .ok_or_else(|| anyhow!("retention sequence overflow")) + })?, + prior_head_envelope_sha256: prior_env.as_ref().map(cultcache_envelope_digest), + runtime_id: authority.store_binding.runtime_id.clone(), + workspace_id: authority.store_binding.workspace_id.clone(), + coverage_binding_id: authority.store_binding.binding_id.clone(), + coverage_binding_envelope_sha256: authority.store_binding_envelope_sha256.clone(), + coverage_store_file_identity: authority.store.file_identity().into(), + retired_envelope_count: prior + .as_ref() + .map_or(0, |value| value.retired_envelope_count) + .checked_add(u64::try_from(deletions.len())?) + .ok_or_else(|| anyhow!("retention envelope count overflow"))?, + retired_identity_digest_root: fold_digest( + "workspace-coverage-retention-identities-v0", + prior_root, + envelope_digests, + ), + family_counts: family_counts + .into_iter() + .map(|(ty, count)| format!("{ty}={count}")) + .collect(), + family_digest_roots: family_roots + .into_iter() + .map(|(ty, root)| format!("{ty}={root}")) + .collect(), + compacted_body_evidence_root: fold_digest( + "workspace-coverage-retention-body-v0", + prior + .as_ref() + .map_or("", |v| v.compacted_body_evidence_root.as_str()), + family(OBLIGATION_TYPE), + ), + compacted_plan_evidence_root: fold_digest( + "workspace-coverage-retention-plan-v0", + prior + .as_ref() + .map_or("", |v| v.compacted_plan_evidence_root.as_str()), + family(PLAN_TYPE), + ), + compacted_claim_evidence_root: fold_digest( + "workspace-coverage-retention-claim-v0", + prior + .as_ref() + .map_or("", |v| v.compacted_claim_evidence_root.as_str()), + family(CLAIM_TYPE), + ), + compacted_receipt_evidence_root: fold_digest( + "workspace-coverage-retention-receipt-v0", + prior + .as_ref() + .map_or("", |v| v.compacted_receipt_evidence_root.as_str()), + family(RECEIPT_TYPE), + ), + compacted_collection_retirement_evidence_root: fold_digest( + "workspace-coverage-retention-collection-retirement-v0", + prior.as_ref().map_or("", |v| { + v.compacted_collection_retirement_evidence_root.as_str() + }), + family(COLLECTION_RETIREMENT_EVIDENCE_TYPE), + ), + compacted_through_body_generation: retired_frontier, + }; + let replacement = envelope(RETENTION_HEAD_TYPE, RETENTION_HEAD_KEY, &head)?; + if !authority.store.replace_and_delete_if_snapshot_unchanged( + &opening, + vec![replacement], + &deletions, + )? { + bail!("workspace coverage retention lost exact snapshot compare-and-swap"); + } + let body_after = crate::load_current_runtime_repository_body_basis(runtime_store)?; + if body_after != body_before { + return Ok(WorkspaceCoverageRetentionResult::HistoricalBodyMovement); + } + Ok(WorkspaceCoverageRetentionResult::Compacted) } pub(crate) trait WorkspaceCoverageRetirementPort { @@ -583,14 +1199,15 @@ fn cultcache_envelope_digest(value: &CultCacheEnvelope) -> String { } pub fn authenticate_workspace_coverage_recovery_receipt( - body_store: impl AsRef, + runtime_store: impl AsRef, cultmesh_store: impl AsRef, runtime_id: &str, host: &HostIncarnationIdentityEntry, recovery_id: &str, expected_digest: &str, ) -> Result<()> { - let opening = SingleFileMessagePackBackingStore::new(body_store.as_ref()).pull_all()?; + let coverage = crate::open_workspace_coverage_authority(runtime_store)?; + let opening = coverage.store.pull_all()?; let receipt_env = find(&opening, RECOVERY_TYPE, recovery_id) .ok_or_else(|| anyhow!("workspace coverage recovery receipt is absent"))?; if cultcache_envelope_digest(receipt_env) != expected_digest { @@ -638,7 +1255,13 @@ pub fn authenticate_workspace_coverage_recovery_receipt( { bail!("workspace coverage recovery receipt external evidence has moved or disagrees"); } - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY) + let claim_env = opening + .iter() + .filter(|entry| entry.r#type == CLAIM_TYPE) + .find(|entry| { + decode::(entry) + .is_ok_and(|claim| claim.claim_id == receipt.new_claim_id) + }) .ok_or_else(|| anyhow!("workspace coverage recovered claim is absent"))?; let claim: WorkspaceCoverageProjectionClaim = decode(claim_env)?; let attempt_env = find(&opening, ATTEMPT_TYPE, &claim.attempt_id) @@ -674,6 +1297,8 @@ pub(crate) struct PreparedWorkspaceCoverageProjection { #[derive(Clone, Debug)] pub(crate) struct WorkspaceCoverageAcquisition { pub body_store: PathBuf, + pub coverage_store: OwnedRedbMessagePackBackingStore, + pub claim_key: String, pub obligation: WorkspaceCoverageObligation, pub plan: WorkspaceCoverageProjectionPlan, pub claim: WorkspaceCoverageProjectionClaim, @@ -681,6 +1306,13 @@ pub(crate) struct WorkspaceCoverageAcquisition { prior_head: Option, } +pub(crate) fn workspace_coverage_claim_key( + body_observation_id: &str, + body_generation: u64, +) -> String { + format!("current/{body_generation}/{body_observation_id}") +} + #[derive(Clone, Debug)] pub(crate) enum WorkspaceCoverageAcquireResult { Current(WorkspaceCoverageReceipt), @@ -710,12 +1342,24 @@ pub struct WorkspaceCoverageTerminalAuthority { /// stronger live query-evidence join. pub fn authenticate_current_workspace_coverage_terminal_authority( runtime_store: &Path, +) -> Result> { + let coverage = crate::open_workspace_coverage_authority(runtime_store)?; + authenticate_current_workspace_coverage_terminal_authority_with_store( + runtime_store, + &coverage.store, + ) +} + +pub(crate) fn authenticate_current_workspace_coverage_terminal_authority_with_store( + runtime_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, ) -> Result> { let basis = crate::load_current_runtime_repository_body_basis(runtime_store)?; let route = runtime_repository_body_store_binding(runtime_store)? .ok_or_else(|| anyhow!("runtime has no repository Body-store binding"))?; - let opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; - exact_body_authority(&opening, &basis)?; + let body_opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; + let body_authority = exact_body_authority(&body_opening, &basis)?; + let opening = coverage_store.pull_all()?; let Some(head_env) = find(&opening, HEAD_TYPE, HEAD_KEY) else { return Ok(None); }; @@ -732,10 +1376,14 @@ pub fn authenticate_current_workspace_coverage_terminal_authority( find(&opening, RECEIPT_TYPE, &head.receipt_id) .ok_or_else(|| anyhow!("current workspace coverage head names a missing receipt"))?, )?; - let claim: WorkspaceCoverageProjectionClaim = decode( - find(&opening, CLAIM_TYPE, CLAIM_KEY) - .ok_or_else(|| anyhow!("current workspace coverage lost its projection claim"))?, - )?; + let Some(claim_env) = find( + &opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&basis.observation_id, basis.generation), + ) else { + return Ok(None); + }; + let claim: WorkspaceCoverageProjectionClaim = decode(claim_env)?; let attempt: WorkspaceCoverageProjectionAttempt = decode( find(&opening, ATTEMPT_TYPE, &claim.attempt_id) .ok_or_else(|| anyhow!("current workspace coverage lost its projection attempt"))?, @@ -772,7 +1420,13 @@ pub fn authenticate_current_workspace_coverage_terminal_authority( if !exact { return Ok(None); } - exact_obligation_body_authority(&opening, &obligation)?; + exact_obligation_body_authority(&body_opening, &obligation)?; + let closing_body = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; + for expected in body_authority { + if find(&closing_body, &expected.r#type, &expected.key) != Some(&expected) { + return Ok(None); + } + } Ok(Some(WorkspaceCoverageTerminalAuthority { body_observation_id: basis.observation_id, body_generation: basis.generation, @@ -800,9 +1454,9 @@ fn collection_compatibility(plan: &WorkspaceCoverageProjectionPlan) -> Collectio /// history. Every attempt is validated before any candidate is returned: one /// malformed historical row refuses the whole GC pass. pub(crate) fn workspace_coverage_retirement_candidates( - body_store: impl AsRef, + coverage_store: &OwnedRedbMessagePackBackingStore, ) -> Result> { - let opening = SingleFileMessagePackBackingStore::new(body_store.as_ref()).pull_all()?; + let opening = coverage_store.pull_all()?; let attempts = opening .iter() @@ -873,6 +1527,11 @@ pub(crate) fn workspace_coverage_retirement_candidates( WorkspaceCoverageRetirementCandidate { collection_name: name, compatibility: collection_compatibility(&plan), + claim_id: attempt.claim_id.clone(), + attempt_id: attempt.attempt_id.clone(), + plan_id: attempt.plan_id.clone(), + body_observation_id: obligation.body_observation_id, + body_generation: obligation.body_generation, }, ); } @@ -880,12 +1539,65 @@ pub(crate) fn workspace_coverage_retirement_candidates( } pub(crate) fn retire_workspace_coverage_collections( - body_store: impl AsRef, + coverage_authority: &crate::WorkspaceCoverageAuthority, port: &mut impl WorkspaceCoverageRetirementPort, ) -> Result { - let candidates = workspace_coverage_retirement_candidates(body_store)?; + let candidates = workspace_coverage_retirement_candidates(&coverage_authority.store)?; for candidate in &candidates { port.retire_exact(&candidate.collection_name, &candidate.compatibility)?; + let compatibility_sha256 = format!( + "sha256-{:x}", + Sha256::digest(rmp_serde::to_vec_named(&candidate.compatibility)?) + ); + let evidence = WorkspaceCoverageCollectionRetirementEvidence { + schema_version: COLLECTION_RETIREMENT_EVIDENCE_SCHEMA.into(), + collection_name: candidate.collection_name.clone(), + collection_compatibility_sha256: compatibility_sha256, + claim_id: candidate.claim_id.clone(), + attempt_id: candidate.attempt_id.clone(), + plan_id: candidate.plan_id.clone(), + body_observation_id: candidate.body_observation_id.clone(), + body_generation: candidate.body_generation, + runtime_id: coverage_authority.store_binding.runtime_id.clone(), + workspace_id: coverage_authority.store_binding.workspace_id.clone(), + coverage_binding_id: coverage_authority.store_binding.binding_id.clone(), + coverage_binding_envelope_sha256: coverage_authority + .store_binding_envelope_sha256 + .clone(), + coverage_store_file_identity: coverage_authority.store.file_identity().into(), + observed_result: "retired-or-absent".into(), + observed_at_utc: chrono::Utc::now().to_rfc3339(), + }; + validate_collection_retirement_evidence(&evidence)?; + let key = candidate.collection_name.clone(); + let replacement = envelope(COLLECTION_RETIREMENT_EVIDENCE_TYPE, &key, &evidence)?; + let opening = coverage_authority.store.pull_all()?; + if let Some(existing) = find(&opening, COLLECTION_RETIREMENT_EVIDENCE_TYPE, &key) { + let prior: WorkspaceCoverageCollectionRetirementEvidence = decode(existing)?; + validate_collection_retirement_evidence(&prior)?; + if prior.collection_name != evidence.collection_name + || prior.collection_compatibility_sha256 != evidence.collection_compatibility_sha256 + || prior.claim_id != evidence.claim_id + || prior.attempt_id != evidence.attempt_id + || prior.plan_id != evidence.plan_id + || prior.body_observation_id != evidence.body_observation_id + || prior.body_generation != evidence.body_generation + || prior.runtime_id != evidence.runtime_id + || prior.workspace_id != evidence.workspace_id + || prior.coverage_binding_id != evidence.coverage_binding_id + || prior.coverage_binding_envelope_sha256 + != evidence.coverage_binding_envelope_sha256 + || prior.coverage_store_file_identity != evidence.coverage_store_file_identity + || prior.observed_result != evidence.observed_result + { + bail!("workspace coverage retirement evidence identity was substituted"); + } + } else if !coverage_authority + .store + .insert_entry_if_absent(replacement)? + { + bail!("workspace coverage retirement evidence lost exact insertion"); + } } Ok(candidates.len()) } @@ -894,6 +1606,7 @@ pub(crate) fn retire_workspace_coverage_collections( /// service's idle path: no Repository Body file is opened or materialized. pub(crate) fn classify_current_workspace_coverage( runtime_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, basis: &RepositoryBodyObservationBasis, embedding_provider_id: &str, embedding_model: &str, @@ -907,8 +1620,9 @@ pub(crate) fn classify_current_workspace_coverage( } let route = runtime_repository_body_store_binding(runtime_store)? .ok_or_else(|| anyhow!("runtime has no repository Body-store binding"))?; - let opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; - exact_body_authority(&opening, basis)?; + let body_opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; + let body_authority = exact_body_authority(&body_opening, basis)?; + let opening = coverage_store.pull_all()?; let Some(head_env) = find(&opening, HEAD_TYPE, HEAD_KEY) else { return Ok(WorkspaceCoverageCurrentState::NeedsPreparation); }; @@ -961,11 +1675,16 @@ pub(crate) fn classify_current_workspace_coverage( && receipt.embedding_provider_id == embedding_provider_id && receipt.embedding_model == embedding_model && receipt.vector_dimensions == vector_dimensions; - Ok(if exact { - WorkspaceCoverageCurrentState::Current(receipt) - } else { - WorkspaceCoverageCurrentState::NeedsPreparation - }) + if !exact { + return Ok(WorkspaceCoverageCurrentState::NeedsPreparation); + } + let closing_body = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; + for expected in body_authority { + if find(&closing_body, &expected.r#type, &expected.key) != Some(&expected) { + return Ok(WorkspaceCoverageCurrentState::NeedsPreparation); + } + } + Ok(WorkspaceCoverageCurrentState::Current(receipt)) } /// Authenticates and re-observes the exact current workspace projection. @@ -982,6 +1701,29 @@ pub(crate) fn observe_current_workspace_coverage_evidence( embedding_model: &str, vector_dimensions: u32, port: &mut impl WorkspaceCoverageEvidencePort, +) -> Result> { + let coverage = crate::open_workspace_coverage_authority(runtime_store)?; + observe_current_workspace_coverage_evidence_with_store( + runtime_store, + &coverage.store, + basis, + policy, + embedding_provider_id, + embedding_model, + vector_dimensions, + port, + ) +} + +pub(crate) fn observe_current_workspace_coverage_evidence_with_store( + runtime_store: &Path, + coverage_store: &OwnedRedbMessagePackBackingStore, + basis: &RepositoryBodyObservationBasis, + policy: &WorkspaceCoveragePolicy, + embedding_provider_id: &str, + embedding_model: &str, + vector_dimensions: u32, + port: &mut impl WorkspaceCoverageEvidencePort, ) -> Result> { if policy.schema_version != crate::WORKSPACE_COVERAGE_POLICY_SCHEMA_VERSION || policy.policy_id.trim().is_empty() @@ -994,8 +1736,9 @@ pub(crate) fn observe_current_workspace_coverage_evidence( } let route = runtime_repository_body_store_binding(runtime_store)? .ok_or_else(|| anyhow!("runtime has no repository Body-store binding"))?; - let opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; - exact_body_authority(&opening, basis)?; + let body_opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; + exact_body_authority(&body_opening, basis)?; + let opening = coverage_store.pull_all()?; let Some(head_env) = find(&opening, HEAD_TYPE, HEAD_KEY) else { return Ok(None); }; @@ -1006,8 +1749,12 @@ pub(crate) fn observe_current_workspace_coverage_evidence( .ok_or_else(|| anyhow!("current workspace coverage head names a missing plan"))?; let receipt_env = find(&opening, RECEIPT_TYPE, &head.receipt_id) .ok_or_else(|| anyhow!("current workspace coverage head names a missing receipt"))?; - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY) - .ok_or_else(|| anyhow!("current workspace coverage lost its projection claim"))?; + let claim_env = find( + &opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&basis.observation_id, basis.generation), + ) + .ok_or_else(|| anyhow!("current workspace coverage lost its projection claim"))?; let obligation: WorkspaceCoverageObligation = decode(obligation_env)?; let plan: WorkspaceCoverageProjectionPlan = decode(plan_env)?; let receipt: WorkspaceCoverageReceipt = decode(receipt_env)?; @@ -1079,8 +1826,19 @@ pub(crate) fn observe_current_workspace_coverage_evidence( if closing_route != route { return Ok(None); } - let closing = + let closing_body = SingleFileMessagePackBackingStore::new(&closing_route.body_store_path).pull_all()?; + let closing = coverage_store.pull_all()?; + for expected in body_opening.iter().filter(|entry| { + matches!( + entry.r#type.as_str(), + BODY_BINDING_TYPE | BODY_HEAD_TYPE | BODY_OBSERVATION_TYPE | BODY_MANIFEST_TYPE + ) + }) { + if find(&closing_body, &expected.r#type, &expected.key) != Some(expected) { + return Ok(None); + } + } for expected in [ head_env, obligation_env, @@ -1202,6 +1960,7 @@ pub(crate) fn prepare_workspace_coverage_projection( pub(crate) fn acquire_workspace_coverage_projection( prepared: &PreparedWorkspaceCoverageProjection, + coverage_store: &OwnedRedbMessagePackBackingStore, executor_id: &str, executor_incarnation: &str, managed_process_launch_id: &str, @@ -1215,14 +1974,15 @@ pub(crate) fn acquire_workspace_coverage_projection( let body_store = prepared.body_store.clone(); let obligation = prepared.obligation.clone(); let plan = prepared.plan.clone(); - let backing = SingleFileMessagePackBackingStore::new(&body_store); - let opening = backing.pull_all()?; + let body_opening = SingleFileMessagePackBackingStore::new(&body_store).pull_all()?; + let opening = coverage_store.pull_all()?; let basis = &prepared.basis; - let authority = exact_body_authority(&opening, basis)?; + let body_authority = exact_body_authority(&body_opening, basis)?; if let Some(receipt) = validate_current_projection(&opening, prepared)? { return Ok(WorkspaceCoverageAcquireResult::Current(receipt)); } - let existing_claim = find(&opening, CLAIM_TYPE, CLAIM_KEY); + let claim_key = workspace_coverage_claim_key(&basis.observation_id, basis.generation); + let existing_claim = find(&opening, CLAIM_TYPE, &claim_key); let claim_epoch = match existing_claim { Some(envelope) => { let prior: WorkspaceCoverageProjectionClaim = decode(envelope)?; @@ -1232,9 +1992,7 @@ pub(crate) fn acquire_workspace_coverage_projection( let prior_attempt: WorkspaceCoverageProjectionAttempt = decode(prior_attempt_env)?; validate_claim_attempt_link(&prior, &prior_attempt)?; if prior.status == "running" { - if prior.schema_version == CLAIM_SCHEMA_V3 - && prior_attempt.schema_version == ATTEMPT_SCHEMA_V3 - && prior.executor_id == executor_id + if prior.executor_id == executor_id && prior.executor_incarnation == executor_incarnation && prior.managed_process_launch_id == managed_process_launch_id && prior.plan_id == plan.plan_id @@ -1246,6 +2004,8 @@ pub(crate) fn acquire_workspace_coverage_projection( return Ok(WorkspaceCoverageAcquireResult::Acquired( WorkspaceCoverageAcquisition { body_store, + coverage_store: coverage_store.clone(), + claim_key, obligation, plan, claim: prior, @@ -1302,11 +2062,11 @@ pub(crate) fn acquire_workspace_coverage_projection( recovery_receipt_id: None, recovery_receipt_digest: None, }; - let mut expected = authority.clone(); + let mut expected = Vec::new(); if let Some(existing) = existing_claim { expected.push(existing.clone()); } - let mut replacements = authority; + let mut replacements = Vec::new(); let obligation_env = envelope( "gamecult.epiphany.workspace_coverage_obligation", &obligation.obligation_id, @@ -1319,14 +2079,22 @@ pub(crate) fn acquire_workspace_coverage_projection( )?; preserve_or_insert_immutable(&opening, &mut expected, &mut replacements, obligation_env)?; preserve_or_insert_immutable(&opening, &mut expected, &mut replacements, plan_env)?; - replacements.push(envelope(CLAIM_TYPE, CLAIM_KEY, &claim)?); + replacements.push(envelope(CLAIM_TYPE, &claim_key, &claim)?); replacements.push(envelope(ATTEMPT_TYPE, &attempt_id, &attempt)?); - if !backing.compare_and_swap_batch(&expected, replacements)? { - bail!("workspace coverage acquisition lost exact Body/claim CAS"); + if !coverage_store.compare_and_swap_batch(&expected, replacements)? { + bail!("workspace coverage acquisition lost exact coverage-store claim CAS"); + } + let closing_body = SingleFileMessagePackBackingStore::new(&body_store).pull_all()?; + for expected in body_authority { + if find(&closing_body, &expected.r#type, &expected.key) != Some(&expected) { + bail!("repository Body changed during workspace coverage acquisition"); + } } Ok(WorkspaceCoverageAcquireResult::Acquired( WorkspaceCoverageAcquisition { body_store, + coverage_store: coverage_store.clone(), + claim_key, obligation, plan, claim, @@ -1343,10 +2111,11 @@ pub fn current_workspace_coverage_recovery_target( runtime_store: impl AsRef, ) -> Result> { let runtime_store = runtime_store.as_ref(); - let route = runtime_repository_body_store_binding(runtime_store)? - .ok_or_else(|| anyhow!("workspace coverage runtime has no Body-store binding"))?; - let opening = SingleFileMessagePackBackingStore::new(&route.body_store_path).pull_all()?; - let Some(claim_env) = find(&opening, CLAIM_TYPE, CLAIM_KEY) else { + let body_basis = observe_runtime_repository_body_basis(runtime_store)?; + let coverage = crate::open_workspace_coverage_authority(runtime_store)?; + let opening = coverage.store.pull_all()?; + let claim_key = workspace_coverage_claim_key(&body_basis.observation_id, body_basis.generation); + let Some(claim_env) = find(&opening, CLAIM_TYPE, &claim_key) else { return Ok(None); }; let claim: WorkspaceCoverageProjectionClaim = decode(claim_env)?; @@ -1441,9 +2210,12 @@ pub fn recover_workspace_coverage_projection( let body_store = PathBuf::from(&body_route.body_store_path); let body_basis = observe_runtime_repository_body_basis(runtime_store)?; RepositoryBodyReadSession::open(runtime_store, &body_basis)?; - let backing = SingleFileMessagePackBackingStore::new(&body_store); - let opening = backing.pull_all()?; - let claim_env = find(&opening, CLAIM_TYPE, CLAIM_KEY) + let body_opening = SingleFileMessagePackBackingStore::new(&body_store).pull_all()?; + let body_authority = exact_body_authority(&body_opening, &body_basis)?; + let coverage = crate::open_workspace_coverage_authority(runtime_store)?; + let opening = coverage.store.pull_all()?; + let claim_key = workspace_coverage_claim_key(&body_basis.observation_id, body_basis.generation); + let claim_env = find(&opening, CLAIM_TYPE, &claim_key) .ok_or_else(|| anyhow!("workspace coverage recovery running claim is absent"))?; let old_claim: WorkspaceCoverageProjectionClaim = decode(claim_env)?; let attempt_env = find(&opening, ATTEMPT_TYPE, &old_claim.attempt_id) @@ -1461,7 +2233,7 @@ pub fn recover_workspace_coverage_projection( bail!("workspace coverage recovery refuses moved, terminal, legacy, or misbound authority"); } - let body_head_env = find(&opening, BODY_HEAD_TYPE, BODY_HEAD_KEY) + let body_head_env = find(&body_opening, BODY_HEAD_TYPE, BODY_HEAD_KEY) .ok_or_else(|| anyhow!("current Body head missing"))?; let body_head: RepositoryBodyHead = decode(body_head_env)?; if body_head.observation_id != old_claim.body_observation_id @@ -1470,26 +2242,6 @@ pub fn recover_workspace_coverage_projection( { bail!("workspace coverage recovery refuses moved Body authority"); } - let mut authority = vec![ - find(&opening, BODY_BINDING_TYPE, BODY_BINDING_KEY) - .cloned() - .ok_or_else(|| anyhow!("Body binding missing"))?, - body_head_env.clone(), - find( - &opening, - BODY_OBSERVATION_TYPE, - &old_claim.body_observation_id, - ) - .cloned() - .ok_or_else(|| anyhow!("Body observation missing"))?, - find( - &opening, - BODY_MANIFEST_TYPE, - &old_claim.manifest_root_sha256, - ) - .cloned() - .ok_or_else(|| anyhow!("Body manifest missing"))?, - ]; let obligation_env = find(&opening, OBLIGATION_TYPE, &old_claim.obligation_id) .cloned() .ok_or_else(|| anyhow!("projection obligation missing"))?; @@ -1514,12 +2266,7 @@ pub fn recover_workspace_coverage_projection( { bail!("workspace coverage recovery refuses substituted plan"); } - authority.push(obligation_env.clone()); - authority.push(plan_env.clone()); let prior_head = find(&opening, HEAD_TYPE, HEAD_KEY).cloned(); - if let Some(head) = &prior_head { - authority.push(head.clone()); - } let claim_epoch = old_claim .claim_epoch @@ -1607,9 +2354,15 @@ pub fn recover_workspace_coverage_projection( recovery_receipt_digest: Some(receipt_digest), }; validate_claim_attempt_link(&claim, &attempt)?; - let mut expected = authority.clone(); + let mut expected = Vec::new(); + if let Some(head) = &prior_head { + expected.push(head.clone()); + } expected.extend([claim_env.clone(), attempt_env.clone()]); - let mut replacements = authority; + let mut replacements = Vec::new(); + if let Some(head) = &prior_head { + replacements.push(head.clone()); + } let history_key = format!("history/{}", old_claim.claim_id); if find(&opening, CLAIM_TYPE, &history_key).is_some() { bail!("workspace coverage recovery claim history identity already exists"); @@ -1621,11 +2374,20 @@ pub fn recover_workspace_coverage_projection( receipt_env, envelope(CLAIM_TYPE, &history_key, &failed_claim)?, envelope(ATTEMPT_TYPE, &failed_attempt.attempt_id, &failed_attempt)?, - envelope(CLAIM_TYPE, CLAIM_KEY, &claim)?, + envelope(CLAIM_TYPE, &claim_key, &claim)?, envelope(ATTEMPT_TYPE, &attempt.attempt_id, &attempt)?, ]); - if !backing.compare_and_swap_batch(&expected, replacements)? { - bail!("workspace coverage recovery lost exact Body/plan/claim/attempt CAS"); + if !coverage + .store + .compare_and_swap_batch(&expected, replacements)? + { + bail!("workspace coverage recovery lost exact coverage-store plan/claim/attempt CAS"); + } + let closing_body = SingleFileMessagePackBackingStore::new(&body_store).pull_all()?; + for expected in body_authority { + if find(&closing_body, &expected.r#type, &expected.key) != Some(&expected) { + bail!("repository Body changed during workspace coverage recovery"); + } } Ok(WorkspaceCoverageRecoveryOutcome { claim_id: claim.claim_id, @@ -1679,10 +2441,9 @@ pub(crate) fn fail_workspace_coverage_projection( if error.trim().is_empty() { bail!("projection failure requires an error"); } - let backing = SingleFileMessagePackBackingStore::new(&acquisition.body_store); - let opening = backing.pull_all()?; - let claim_env = - find(&opening, CLAIM_TYPE, CLAIM_KEY).ok_or_else(|| anyhow!("running claim missing"))?; + let opening = acquisition.coverage_store.pull_all()?; + let claim_env = find(&opening, CLAIM_TYPE, &acquisition.claim_key) + .ok_or_else(|| anyhow!("running claim missing"))?; let attempt_env = find(&opening, ATTEMPT_TYPE, &acquisition.attempt.attempt_id) .ok_or_else(|| anyhow!("running attempt missing"))?; let claim: WorkspaceCoverageProjectionClaim = decode(claim_env)?; @@ -1722,10 +2483,13 @@ pub(crate) fn fail_workspace_coverage_projection( let replacements = vec![ obligation_env.clone(), plan_env.clone(), - envelope(CLAIM_TYPE, CLAIM_KEY, &failed_claim)?, + envelope(CLAIM_TYPE, &acquisition.claim_key, &failed_claim)?, envelope(ATTEMPT_TYPE, &failed_attempt.attempt_id, &failed_attempt)?, ]; - if !backing.compare_and_swap_batch(&expected, replacements)? { + if !acquisition + .coverage_store + .compare_and_swap_batch(&expected, replacements)? + { bail!("projection failure lost exact claim/attempt CAS"); } Ok(()) @@ -1786,33 +2550,25 @@ fn execute_batched_and_commit( let checkpoint_chain = load_authenticated_checkpoint_chain( &acquisition.body_store, + &authority.coverage_authority.store, authority.local_verse_store, authority.trusted_host, &acquisition.claim.claim_id, acquisition.claim.claim_epoch, )?; let mut next_ordinal = if let Some(current) = checkpoint_chain.last() { - reconcile_workspace_coverage_checkpoint_progress( - &acquisition.body_store, - authority.local_verse_store, - authority.runtime_id, - authority.trusted_host, - authority.provider_signing_key, - &acquisition.claim.claim_id, - acquisition.claim.claim_epoch, - )?; for checkpoint in &checkpoint_chain { authenticate_checkpoint_readback(&collection_name, &checkpoint.checkpoint, port)?; } current.checkpoint.cumulative_point_count as usize } else { if let Some(existing) = load_latest_workspace_coverage_projection_progress( - authority.local_verse_store, - authority.runtime_id, + &authority.coverage_authority.store, &acquisition.claim.managed_process_launch_id, &acquisition.claim.claim_id, )? { let existing = authenticate_workspace_coverage_projection_progress( + &authority.coverage_authority.store, authority.local_verse_store, authority.runtime_id, &existing.progress_id, @@ -1829,6 +2585,7 @@ fn execute_batched_and_commit( } else { publish_workspace_coverage_progress_genesis( &acquisition.body_store, + &authority.coverage_authority.store, authority.local_verse_store, authority.runtime_id, authority.trusted_host, @@ -1884,8 +2641,9 @@ fn execute_batched_and_commit( &points, acquisition.plan.vector_dimensions, )?; - let checkpoint = admit_observed_workspace_coverage_batch( + let admitted = admit_observed_workspace_coverage_batch( &acquisition.body_store, + &authority.coverage_authority.store, authority.local_verse_store, authority.runtime_id, authority.trusted_host, @@ -1899,17 +2657,24 @@ fn execute_batched_and_commit( vector_bindings: stored_vector_bindings, }, )?; - publish_workspace_coverage_progress_for_checkpoint( + publish_workspace_coverage_advancement_sight( authority.local_verse_store, + authority.runtime_store, + authority.coverage_authority, authority.runtime_id, + &acquisition.claim.managed_process_launch_id, + authority.trusted_host, authority.provider_signing_key, - &checkpoint, + chrono::Utc::now(), + chrono::Duration::seconds(1), )?; + debug_assert_eq!(admitted.checkpoint.claim_id, acquisition.claim.claim_id); next_ordinal = end; } let final_chain = load_authenticated_checkpoint_chain( &acquisition.body_store, + &authority.coverage_authority.store, authority.local_verse_store, authority.trusted_host, &acquisition.claim.claim_id, @@ -1922,7 +2687,18 @@ fn execute_batched_and_commit( port.observe_all(&collection_name)?, &final_chain, )?; - commit_workspace_coverage_success(acquisition, observed) + let receipt = commit_workspace_coverage_success(acquisition, observed)?; + publish_workspace_coverage_terminal_sight( + authority.local_verse_store, + authority.runtime_store, + authority.coverage_authority, + authority.runtime_id, + &acquisition.claim.managed_process_launch_id, + authority.trusted_host, + authority.provider_signing_key, + chrono::Utc::now(), + )?; + Ok(receipt) } fn authenticate_checkpoint_readback( @@ -2414,7 +3190,7 @@ fn same_vector_binding_set( observed == expected } -fn commit_workspace_coverage_success( +pub(crate) fn commit_workspace_coverage_success( acquisition: &WorkspaceCoverageAcquisition, observed: WorkspaceCoverageObservedBinding, ) -> Result { @@ -2424,9 +3200,10 @@ fn commit_workspace_coverage_success( { bail!("observed binding proof is not the sealed plan"); } - let backing = SingleFileMessagePackBackingStore::new(&acquisition.body_store); - let opening = backing.pull_all()?; - let authority = exact_obligation_body_authority(&opening, &acquisition.obligation)?; + let body_opening = + SingleFileMessagePackBackingStore::new(&acquisition.body_store).pull_all()?; + let body_authority = exact_obligation_body_authority(&body_opening, &acquisition.obligation)?; + let opening = acquisition.coverage_store.pull_all()?; let obligation_env = find( &opening, "gamecult.epiphany.workspace_coverage_obligation", @@ -2439,8 +3216,8 @@ fn commit_workspace_coverage_success( &acquisition.plan.plan_id, ) .ok_or_else(|| anyhow!("persisted projection plan missing"))?; - let claim_env = - find(&opening, CLAIM_TYPE, CLAIM_KEY).ok_or_else(|| anyhow!("running claim missing"))?; + let claim_env = find(&opening, CLAIM_TYPE, &acquisition.claim_key) + .ok_or_else(|| anyhow!("running claim missing"))?; let attempt_env = find(&opening, ATTEMPT_TYPE, &acquisition.attempt.attempt_id) .ok_or_else(|| anyhow!("running attempt missing"))?; if decode::(obligation_env)? != acquisition.obligation @@ -2499,7 +3276,7 @@ fn commit_workspace_coverage_success( let mut completed_attempt = acquisition.attempt.clone(); completed_attempt.status = "succeeded".into(); completed_attempt.completed_at = Some(chrono::Utc::now().to_rfc3339()); - let mut expected = authority.clone(); + let mut expected = Vec::new(); expected.extend([ obligation_env.clone(), plan_env.clone(), @@ -2509,11 +3286,11 @@ fn commit_workspace_coverage_success( if let Some(prior_head) = &acquisition.prior_head { expected.push(prior_head.clone()); } - let mut replacements = authority; + let mut replacements = Vec::new(); replacements.extend([ obligation_env.clone(), plan_env.clone(), - envelope(CLAIM_TYPE, CLAIM_KEY, &completed_claim)?, + envelope(CLAIM_TYPE, &acquisition.claim_key, &completed_claim)?, envelope( ATTEMPT_TYPE, &completed_attempt.attempt_id, @@ -2522,8 +3299,18 @@ fn commit_workspace_coverage_success( envelope(RECEIPT_TYPE, &receipt.receipt_id, &receipt)?, envelope(HEAD_TYPE, HEAD_KEY, &head)?, ]); - if !backing.compare_and_swap_batch(&expected, replacements)? { - bail!("workspace coverage success lost exact Body/plan/claim CAS"); + if !acquisition + .coverage_store + .compare_and_swap_batch(&expected, replacements)? + { + bail!("workspace coverage success lost exact coverage-store plan/claim CAS"); + } + let closing_body = + SingleFileMessagePackBackingStore::new(&acquisition.body_store).pull_all()?; + for expected in body_authority { + if find(&closing_body, &expected.r#type, &expected.key) != Some(&expected) { + bail!("repository Body changed during workspace coverage terminal commit"); + } } Ok(receipt) } @@ -3130,7 +3917,8 @@ mod tests { struct AdvancingEvidencePort { inner: FakeProjectionPort, - body_store: PathBuf, + coverage_store: OwnedRedbMessagePackBackingStore, + claim_key: String, } impl WorkspaceCoverageEvidencePort for AdvancingEvidencePort { @@ -3148,16 +3936,15 @@ mod tests { collection: &str, ) -> Result>> { let points = self.inner.observe_all_for_evidence(collection)?; - let backing = SingleFileMessagePackBackingStore::new(&self.body_store); - let opening = backing.pull_all()?; - let current = find(&opening, CLAIM_TYPE, CLAIM_KEY) + let opening = self.coverage_store.pull_all()?; + let current = find(&opening, CLAIM_TYPE, &self.claim_key) .ok_or_else(|| anyhow!("test current claim disappeared"))? .clone(); let mut advanced: WorkspaceCoverageProjectionClaim = decode(¤t)?; advanced.executor_id.push_str("-advanced"); - if !backing.compare_and_swap_batch( + if !self.coverage_store.compare_and_swap_batch( &[current], - vec![envelope(CLAIM_TYPE, CLAIM_KEY, &advanced)?], + vec![envelope(CLAIM_TYPE, &self.claim_key, &advanced)?], )? { bail!("test authority advance lost its CAS"); } @@ -3214,6 +4001,8 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "retirement-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-16T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body, &runtime, "retirement-workspace")?; + let coverage = std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"); + crate::bind_runtime_workspace_coverage_store(&runtime, &coverage, "2026-07-16T00:00:02Z")?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; Ok((repo, state, runtime, basis)) } @@ -3228,8 +4017,9 @@ mod tests { failed.claim.claim_epoch, )?; fail_workspace_coverage_projection(&failed, "backend refused")?; + drop(failed); let (_, running) = acquire_test(&runtime, &basis, "provider", "model", 3)?; - let candidates = workspace_coverage_retirement_candidates(&running.body_store)?; + let candidates = workspace_coverage_retirement_candidates(&running.coverage_store)?; assert_eq!( candidates .iter() @@ -3258,18 +4048,19 @@ mod tests { projection_inputs(&acquired_a, repo.path())?, &mut FakeProjectionPort::new(Hostility::Honest), )?; - assert!(workspace_coverage_retirement_candidates(&acquired_a.body_store)?.is_empty()); + assert!(workspace_coverage_retirement_candidates(&acquired_a.coverage_store)?.is_empty()); std::fs::write(repo.path().join("source.rs"), "fn two() {}\n")?; let basis_b = crate::observe_runtime_repository_body_basis(&runtime)?; + drop(acquired_a); let (_, acquired_b) = acquire_test(&runtime, &basis_b, "provider", "model", 3)?; - assert!(workspace_coverage_retirement_candidates(&acquired_b.body_store)?.is_empty()); + assert!(workspace_coverage_retirement_candidates(&acquired_b.coverage_store)?.is_empty()); execute_preembedded_workspace_coverage_projection( &acquired_b, projection_inputs(&acquired_b, repo.path())?, &mut FakeProjectionPort::new(Hostility::Honest), )?; - let candidates = workspace_coverage_retirement_candidates(&acquired_b.body_store)?; + let candidates = workspace_coverage_retirement_candidates(&acquired_b.coverage_store)?; assert_eq!(candidates.len(), 1); assert_eq!(candidates[0].collection_name, receipt_a.collection_name); Ok(()) @@ -3280,20 +4071,23 @@ mod tests { let (_repo, _state, runtime, basis) = coverage_fixture()?; let (_, acquired) = acquire_test(&runtime, &basis, "provider", "model", 3)?; fail_workspace_coverage_projection(&acquired, "failed")?; - let candidate = workspace_coverage_retirement_candidates(&acquired.body_store)?.remove(0); + let candidate = + workspace_coverage_retirement_candidates(&acquired.coverage_store)?.remove(0); let mut port = FakeRetirementPort::default(); let mut incompatible = candidate.compatibility.clone(); incompatible.embedding_model.push_str("-alien"); port.present .insert(candidate.collection_name.clone(), incompatible); - assert!(retire_workspace_coverage_collections(&acquired.body_store, &mut port).is_err()); + drop(acquired); + let authority = crate::open_workspace_coverage_authority(&runtime)?; + assert!(retire_workspace_coverage_collections(&authority, &mut port).is_err()); port.present.clear(); assert_eq!( - retire_workspace_coverage_collections(&acquired.body_store, &mut port)?, + retire_workspace_coverage_collections(&authority, &mut port)?, 1 ); assert_eq!( - retire_workspace_coverage_collections(&acquired.body_store, &mut port)?, + retire_workspace_coverage_collections(&authority, &mut port)?, 1 ); assert!(port.retired.is_empty()); @@ -3335,8 +4129,20 @@ mod tests { )> { let body = RepositoryBodyReadSession::open(runtime, basis)?; let prepared = prepare_workspace_coverage_projection(&body, provider, model, dimensions)?; + let coverage = crate::open_workspace_coverage_authority(runtime)?; + acquire_test_with_store(prepared, &coverage.store) + } + + fn acquire_test_with_store( + prepared: PreparedWorkspaceCoverageProjection, + coverage_store: &OwnedRedbMessagePackBackingStore, + ) -> Result<( + PreparedWorkspaceCoverageProjection, + WorkspaceCoverageAcquisition, + )> { let acquisition = match acquire_workspace_coverage_projection( &prepared, + coverage_store, "test-executor", "test-incarnation", "test-startup-receipt", @@ -3368,8 +4174,9 @@ mod tests { WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES, )?; - let evidence = observe_current_workspace_coverage_evidence( + let evidence = observe_current_workspace_coverage_evidence_with_store( &runtime, + &acquisition.coverage_store, &basis, &policy, "provider", @@ -3390,8 +4197,9 @@ mod tests { WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES - 1, )?; assert!( - observe_current_workspace_coverage_evidence( + observe_current_workspace_coverage_evidence_with_store( &runtime, + &acquisition.coverage_store, &basis, &wrong_policy, "provider", @@ -3411,12 +4219,22 @@ mod tests { let inputs = projection_inputs(&acquisition, repo.path())?; let mut projection = FakeProjectionPort::new(Hostility::Honest); execute_preembedded_workspace_coverage_projection(&acquisition, inputs, &mut projection)?; - let terminal = authenticate_current_workspace_coverage_terminal_authority(&runtime)? - .expect("succeeded current receipt/head must own terminal health"); + let terminal = authenticate_current_workspace_coverage_terminal_authority_with_store( + &runtime, + &acquisition.coverage_store, + )? + .expect("succeeded current receipt/head must own terminal health"); assert_eq!(terminal.claim_id, acquisition.claim.claim_id); assert_eq!(terminal.plan_id, acquisition.plan.plan_id); assert!(matches!( - classify_current_workspace_coverage(&runtime, &basis, "provider", "model", 3)?, + classify_current_workspace_coverage( + &runtime, + &acquisition.coverage_store, + &basis, + "provider", + "model", + 3, + )?, WorkspaceCoverageCurrentState::Current(_) )); let policy = WorkspaceCoveragePolicy::bounded_regular_files_v0( @@ -3426,8 +4244,9 @@ mod tests { let mut missing_live_collection = FakeProjectionPort::new(Hostility::Honest); missing_live_collection.collection_present = false; assert!( - observe_current_workspace_coverage_evidence( + observe_current_workspace_coverage_evidence_with_store( &runtime, + &acquisition.coverage_store, &basis, &policy, "provider", @@ -3451,8 +4270,9 @@ mod tests { .expect("test collection compatibility") .vector_size += 1; assert!( - observe_current_workspace_coverage_evidence( + observe_current_workspace_coverage_evidence_with_store( &runtime, + &acquisition.coverage_store, &basis, &policy, "provider", @@ -3472,8 +4292,9 @@ mod tests { collection_compatibility: projection.collection_compatibility.clone(), }; assert!( - observe_current_workspace_coverage_evidence( + observe_current_workspace_coverage_evidence_with_store( &runtime, + &acquisition.coverage_store, &basis, &policy, "provider", @@ -3497,10 +4318,49 @@ mod tests { inputs, &mut FakeProjectionPort::new(Hostility::Honest), )?; - assert!(authenticate_current_workspace_coverage_terminal_authority(&runtime)?.is_some()); + assert!( + authenticate_current_workspace_coverage_terminal_authority_with_store( + &runtime, + &acquisition.coverage_store, + )? + .is_some() + ); std::fs::write(repo.path().join("source.rs"), "pub fn changed() {}\n")?; crate::observe_runtime_repository_body_basis(&runtime)?; - assert!(authenticate_current_workspace_coverage_terminal_authority(&runtime)?.is_none()); + assert!( + authenticate_current_workspace_coverage_terminal_authority_with_store( + &runtime, + &acquisition.coverage_store, + )? + .is_none() + ); + Ok(()) + } + + #[test] + fn sight_publication_refuses_body_movement_after_entry_construction() -> Result<()> { + let (repo, _state, runtime, basis) = coverage_fixture()?; + let authority = crate::open_workspace_coverage_authority(&runtime)?; + crate::workspace_coverage_process_documents::validate_workspace_coverage_sight_closing_authority( + &runtime, + &authority, + &basis.workspace_id, + &basis.body_binding_sha256, + &basis.observation_id, + basis.generation, + &basis.manifest_root_sha256, + )?; + std::fs::write(repo.path().join("source.rs"), "pub fn moved() {}\n")?; + crate::observe_runtime_repository_body_basis(&runtime)?; + assert!(crate::workspace_coverage_process_documents::validate_workspace_coverage_sight_closing_authority( + &runtime, + &authority, + &basis.workspace_id, + &basis.body_binding_sha256, + &basis.observation_id, + basis.generation, + &basis.manifest_root_sha256, + ).is_err()); Ok(()) } @@ -3511,21 +4371,18 @@ mod tests { let inputs = projection_inputs(&acquisition, repo.path())?; let mut projection = FakeProjectionPort::new(Hostility::Honest); execute_preembedded_workspace_coverage_projection(&acquisition, inputs, &mut projection)?; - let body_store = PathBuf::from( - runtime_repository_body_store_binding(&runtime)? - .expect("runtime Body route") - .body_store_path, - ); let mut advancing = AdvancingEvidencePort { inner: projection, - body_store, + coverage_store: acquisition.coverage_store.clone(), + claim_key: acquisition.claim_key.clone(), }; let policy = WorkspaceCoveragePolicy::bounded_regular_files_v0( WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES, )?; assert!( - observe_current_workspace_coverage_evidence( + observe_current_workspace_coverage_evidence_with_store( &runtime, + &acquisition.coverage_store, &basis, &policy, "provider", @@ -3629,6 +4486,12 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "read-session-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-16T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body_store, &runtime, "read-session-workspace")?; + let coverage_store = std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"); + crate::bind_runtime_workspace_coverage_store( + &runtime, + &coverage_store, + "2026-07-16T00:00:02Z", + )?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; crate::repository_body_observer::reset_repository_body_read_counters(); @@ -3641,6 +4504,7 @@ mod tests { let acquisition = match acquire_workspace_coverage_projection( &prepared, + &crate::open_workspace_coverage_authority(&runtime)?.store, "test-executor", "test-incarnation", "test-startup-receipt", @@ -3655,7 +4519,14 @@ mod tests { &mut FakeProjectionPort::new(Hostility::Honest), )?; crate::repository_body_observer::reset_repository_body_read_counters(); - match classify_current_workspace_coverage(&runtime, &basis, "provider", "model", 3)? { + match classify_current_workspace_coverage( + &runtime, + &acquisition.coverage_store, + &basis, + "provider", + "model", + 3, + )? { WorkspaceCoverageCurrentState::Current(current) => assert_eq!(current, receipt), WorkspaceCoverageCurrentState::NeedsPreparation => { bail!("exact projection was not current") @@ -3691,6 +4562,11 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "projector-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-15T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body, &runtime, "projector-workspace")?; + crate::bind_runtime_workspace_coverage_store( + &runtime, + std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"), + "2026-07-15T00:00:02Z", + )?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; let (_, first) = acquire_test(&runtime, &basis, "provider", "model", 3)?; assert!(first.obligation.classifications.iter().any(|entry| { @@ -3699,15 +4575,35 @@ mod tests { == crate::WorkspaceCoverageDisposition::ExcludeNonUtf8RegularFile })); assert_eq!(first.obligation.included_entry_count, 1); - assert!(acquire_test(&runtime, &basis, "provider", "model", 3).is_err()); + assert!(matches!( + acquire_workspace_coverage_projection( + &prepare_workspace_coverage_projection( + &RepositoryBodyReadSession::open(&runtime, &basis)?, + "provider", + "model", + 3, + )?, + &first.coverage_store, + "other-executor", + "other-incarnation", + "other-startup-receipt", + )?, + WorkspaceCoverageAcquireResult::Contended + )); fail_workspace_coverage_projection(&first, "expected test failure")?; - let (_, second) = acquire_test(&runtime, &basis, "provider", "model", 3)?; + let second_prepared = prepare_workspace_coverage_projection( + &RepositoryBodyReadSession::open(&runtime, &basis)?, + "provider", + "model", + 3, + )?; + let (_, second) = acquire_test_with_store(second_prepared, &first.coverage_store)?; assert_eq!(second.claim.claim_epoch, first.claim.claim_epoch + 1); std::fs::write(repo.path().join("source.rs"), "fn two() {}")?; let advanced = crate::observe_runtime_repository_body_basis(&runtime)?; assert!(advanced.generation > basis.generation); fail_workspace_coverage_projection(&second, "Body advanced during projection")?; - let entries = SingleFileMessagePackBackingStore::new(&second.body_store).pull_all()?; + let entries = second.coverage_store.pull_all()?; assert!( find( &entries, @@ -3765,16 +4661,35 @@ mod tests { &runtime, "projection-execution-workspace", )?; + let coverage = std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"); + crate::bind_runtime_workspace_coverage_store( + &runtime, + &coverage, + "2026-07-15T00:00:02Z", + )?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; let inputs = projection_inputs(&acquisition, repo.path())?; + let body_bytes_before = std::fs::read(&acquisition.body_store)?; let result = execute_preembedded_workspace_coverage_projection( &acquisition, inputs, &mut FakeProjectionPort::new(hostility), ); - let entries = + let entries = acquisition.coverage_store.pull_all()?; + assert_eq!(std::fs::read(&acquisition.body_store)?, body_bytes_before); + assert!(entries.iter().all(|entry| !matches!( + entry.r#type.as_str(), + BODY_BINDING_TYPE | BODY_HEAD_TYPE | BODY_OBSERVATION_TYPE | BODY_MANIFEST_TYPE + ))); + let body_entries = SingleFileMessagePackBackingStore::new(&acquisition.body_store).pull_all()?; + assert!( + body_entries.iter().all(|entry| !entry + .r#type + .starts_with("gamecult.epiphany.workspace_coverage")), + "workspace coverage authority contaminated the read-only Body store" + ); match hostility { Hostility::Honest => { let receipt = result?; @@ -3785,6 +4700,7 @@ mod tests { prepare_workspace_coverage_projection(&body, "provider", "model", 3)?; match acquire_workspace_coverage_projection( &prepared, + &acquisition.coverage_store, "replacement-executor", "replacement-incarnation", "replacement-startup-receipt", @@ -3799,7 +4715,7 @@ mod tests { bail!("exact current projection was contended") } } - let backing = SingleFileMessagePackBackingStore::new(&acquisition.body_store); + let backing = acquisition.coverage_store.clone(); let before_corruption = backing.pull_all()?; let receipt_env = find(&before_corruption, RECEIPT_TYPE, &receipt.receipt_id) .unwrap() @@ -3813,6 +4729,7 @@ mod tests { assert!( acquire_workspace_coverage_projection( &prepared, + &acquisition.coverage_store, "replacement-executor", "replacement-incarnation", "replacement-startup-receipt", @@ -3824,7 +4741,7 @@ mod tests { assert!(result.is_err()); assert!(find(&entries, RECEIPT_TYPE, HEAD_KEY).is_none()); let claim: WorkspaceCoverageProjectionClaim = - decode(find(&entries, CLAIM_TYPE, CLAIM_KEY).unwrap())?; + decode(find(&entries, CLAIM_TYPE, &acquisition.claim_key).unwrap())?; assert_eq!(claim.status, "failed"); } } @@ -3853,6 +4770,11 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "body-advance-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-15T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body, &runtime, "body-advance-workspace")?; + crate::bind_runtime_workspace_coverage_store( + &runtime, + std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"), + "2026-07-15T00:00:02Z", + )?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; let inputs = projection_inputs(&acquisition, repo.path())?; @@ -3866,10 +4788,10 @@ mod tests { ) .is_err() ); - let entries = SingleFileMessagePackBackingStore::new(&acquisition.body_store).pull_all()?; + let entries = acquisition.coverage_store.pull_all()?; assert!(find(&entries, HEAD_TYPE, HEAD_KEY).is_none()); let claim: WorkspaceCoverageProjectionClaim = - decode(find(&entries, CLAIM_TYPE, CLAIM_KEY).unwrap())?; + decode(find(&entries, CLAIM_TYPE, &acquisition.claim_key).unwrap())?; assert_eq!(claim.status, "failed"); Ok(()) } @@ -3895,6 +4817,11 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "cas-loser-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-15T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body, &runtime, "cas-loser-workspace")?; + crate::bind_runtime_workspace_coverage_store( + &runtime, + std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"), + "2026-07-15T00:00:02Z", + )?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; let collection_name = workspace_coverage_execution_collection( @@ -3919,7 +4846,7 @@ mod tests { vector_binding_set_sha256: "ee".repeat(32), }; assert!(commit_workspace_coverage_success(&acquisition, exact_but_late).is_err()); - let entries = SingleFileMessagePackBackingStore::new(&acquisition.body_store).pull_all()?; + let entries = acquisition.coverage_store.pull_all()?; assert!(find(&entries, HEAD_TYPE, HEAD_KEY).is_none()); assert!(!entries.iter().any(|entry| entry.r#type == RECEIPT_TYPE)); Ok(()) @@ -3946,6 +4873,11 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "empty-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-15T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body, &runtime, "empty-workspace")?; + crate::bind_runtime_workspace_coverage_store( + &runtime, + std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"), + "2026-07-15T00:00:02Z", + )?; let basis = crate::observe_runtime_repository_body_basis(&runtime)?; let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; assert!(acquisition.plan.planned_points.is_empty()); @@ -3978,6 +4910,11 @@ mod tests { crate::ensure_agent_memory_swarm_identity(&agents, "head-cas-swarm")?; crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-15T00:00:01Z")?; crate::bind_repository_body(repo.path(), &body, &runtime, "head-cas-workspace")?; + crate::bind_runtime_workspace_coverage_store( + &runtime, + std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"), + "2026-07-15T00:00:02Z", + )?; let basis_a = crate::observe_runtime_repository_body_basis(&runtime)?; let (_, acquisition_a) = acquire_test(&runtime, &basis_a, "provider", "model", 3)?; @@ -3987,13 +4924,20 @@ mod tests { inputs_a, &mut FakeProjectionPort::new(Hostility::Honest), )?; - let backing = SingleFileMessagePackBackingStore::new(&acquisition_a.body_store); + let backing = acquisition_a.coverage_store.clone(); let after_a = backing.pull_all()?; let head_a = find(&after_a, HEAD_TYPE, HEAD_KEY).unwrap().clone(); std::fs::write(repo.path().join("source.rs"), "fn b() {}\n")?; let basis_b = crate::observe_runtime_repository_body_basis(&runtime)?; - let (_, acquisition_b) = acquire_test(&runtime, &basis_b, "provider", "model", 3)?; + let prepared_b = prepare_workspace_coverage_projection( + &RepositoryBodyReadSession::open(&runtime, &basis_b)?, + "provider", + "model", + 3, + )?; + let (_, acquisition_b) = + acquire_test_with_store(prepared_b, &acquisition_a.coverage_store)?; assert_eq!(acquisition_b.prior_head.as_ref(), Some(&head_a)); let inputs_b = projection_inputs(&acquisition_b, repo.path())?; execute_preembedded_workspace_coverage_projection( @@ -4008,7 +4952,14 @@ mod tests { std::fs::write(repo.path().join("source.rs"), "fn c() {}\n")?; let basis_c = crate::observe_runtime_repository_body_basis(&runtime)?; - let (_, acquisition_c) = acquire_test(&runtime, &basis_c, "provider", "model", 3)?; + let prepared_c = prepare_workspace_coverage_projection( + &RepositoryBodyReadSession::open(&runtime, &basis_c)?, + "provider", + "model", + 3, + )?; + let (_, acquisition_c) = + acquire_test_with_store(prepared_c, &acquisition_a.coverage_store)?; assert_eq!(acquisition_c.prior_head.as_ref(), Some(&head_b)); assert!(backing.compare_and_swap_batch(&[head_b], vec![head_a.clone()])?); let inputs_c = projection_inputs(&acquisition_c, repo.path())?; @@ -4031,4 +4982,265 @@ mod tests { ); Ok(()) } + + #[test] + fn retention_bounds_retired_generations_to_one_accumulator_without_touching_body() -> Result<()> + { + let (repo, _state, runtime, mut basis) = coverage_fixture()?; + let mut retired_claims = Vec::new(); + let mut retention_sequences = Vec::new(); + for generation in 1..=4 { + if generation > 1 { + std::fs::write( + repo.path().join("source.rs"), + format!("fn generation_{generation}() {{}}\n"), + )?; + basis = crate::observe_runtime_repository_body_basis(&runtime)?; + } + let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; + let claim_id = acquisition.claim.claim_id.clone(); + execute_preembedded_workspace_coverage_projection( + &acquisition, + projection_inputs(&acquisition, repo.path())?, + &mut FakeProjectionPort::new(Hostility::Honest), + )?; + retired_claims.push(claim_id); + drop(acquisition); + let authority = crate::open_workspace_coverage_authority(&runtime)?; + retire_workspace_coverage_collections(&authority, &mut FakeRetirementPort::default())?; + let result = compact_workspace_coverage_history(&runtime, &authority)?; + let opening = authority.store.pull_all()?; + let retention = find(&opening, RETENTION_HEAD_TYPE, RETENTION_HEAD_KEY) + .map(decode::) + .transpose()?; + if let Some(retention) = retention { + retention_sequences.push(retention.sequence); + } + if generation >= 3 { + assert_eq!(result, WorkspaceCoverageRetentionResult::Compacted); + assert!(!opening.iter().any(|entry| { + entry.r#type == CLAIM_TYPE + && decode::(entry) + .is_ok_and(|claim| claim.claim_id == retired_claims[generation - 3]) + })); + assert!(opening.iter().any(|entry| { + entry.r#type == CLAIM_TYPE + && decode::(entry) + .is_ok_and(|claim| claim.claim_id == retired_claims[generation - 2]) + })); + let current_claim: WorkspaceCoverageProjectionClaim = decode( + find( + &opening, + CLAIM_TYPE, + &workspace_coverage_claim_key(&basis.observation_id, basis.generation), + ) + .expect("current terminal claim must remain reachable"), + )?; + assert_eq!(current_claim.status, "succeeded"); + } else { + assert_eq!(result, WorkspaceCoverageRetentionResult::Noop); + } + assert_eq!( + opening + .iter() + .filter(|entry| entry.r#type == RETENTION_HEAD_TYPE) + .count(), + usize::from(generation >= 3) + ); + drop(authority); + } + assert_eq!(retention_sequences, vec![1, 2]); + let route = runtime_repository_body_store_binding(&runtime)?.expect("Body route"); + let body = SingleFileMessagePackBackingStore::new(route.body_store_path).pull_all()?; + assert!(body.iter().all(|entry| entry.r#type != RETENTION_HEAD_TYPE)); + + let authority = crate::open_workspace_coverage_authority(&runtime)?; + let opening = authority.store.pull_all()?; + let prior_env = find(&opening, RETENTION_HEAD_TYPE, RETENTION_HEAD_KEY) + .expect("retention head") + .clone(); + let mut forked: WorkspaceCoverageRetentionHead = decode(&prior_env)?; + let mut duplicate_family = forked.clone(); + duplicate_family + .family_counts + .push(duplicate_family.family_counts[0].clone()); + assert!(validate_retention_head(&duplicate_family, &authority).is_err()); + forked.coverage_binding_id.push_str("-fork"); + assert!(validate_retention_head(&forked, &authority).is_err()); + let mut frontier_fork: WorkspaceCoverageRetentionHead = decode(&prior_env)?; + frontier_fork.compacted_through_body_generation = u64::MAX; + assert!(authority.store.compare_and_swap_entry( + &prior_env, + envelope(RETENTION_HEAD_TYPE, RETENTION_HEAD_KEY, &frontier_fork)?, + )?); + drop(authority); + std::fs::write(repo.path().join("source.rs"), "fn generation_5() {}\n")?; + basis = crate::observe_runtime_repository_body_basis(&runtime)?; + let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; + execute_preembedded_workspace_coverage_projection( + &acquisition, + projection_inputs(&acquisition, repo.path())?, + &mut FakeProjectionPort::new(Hostility::Honest), + )?; + drop(acquisition); + let authority = crate::open_workspace_coverage_authority(&runtime)?; + retire_workspace_coverage_collections(&authority, &mut FakeRetirementPort::default())?; + let before_refusal = authority.store.pull_all()?; + assert!(compact_workspace_coverage_history(&runtime, &authority).is_err()); + assert_eq!(authority.store.pull_all()?, before_refusal); + Ok(()) + } + + #[test] + fn retention_head_alone_grants_no_current_readiness_terminal_or_recovery_authority() + -> Result<()> { + let (_repo, _state, runtime, basis) = coverage_fixture()?; + let authority = crate::open_workspace_coverage_authority(&runtime)?; + let digest = format!("sha256-{}", "00".repeat(32)); + let head = WorkspaceCoverageRetentionHead { + schema_version: RETENTION_HEAD_SCHEMA.into(), + sequence: 1, + prior_head_envelope_sha256: None, + runtime_id: authority.store_binding.runtime_id.clone(), + workspace_id: authority.store_binding.workspace_id.clone(), + coverage_binding_id: authority.store_binding.binding_id.clone(), + coverage_binding_envelope_sha256: authority.store_binding_envelope_sha256.clone(), + coverage_store_file_identity: authority.store.file_identity().into(), + retired_envelope_count: 12, + retired_identity_digest_root: digest.clone(), + family_counts: vec![format!("{CLAIM_TYPE}=12")], + family_digest_roots: vec![format!("{CLAIM_TYPE}={digest}")], + compacted_body_evidence_root: digest.clone(), + compacted_plan_evidence_root: digest.clone(), + compacted_claim_evidence_root: digest.clone(), + compacted_receipt_evidence_root: digest.clone(), + compacted_collection_retirement_evidence_root: digest, + compacted_through_body_generation: basis.generation, + }; + assert!(authority.store.insert_entry_if_absent(envelope( + RETENTION_HEAD_TYPE, + RETENTION_HEAD_KEY, + &head, + )?)?); + assert!(matches!( + classify_current_workspace_coverage( + &runtime, + &authority.store, + &basis, + "provider", + "model", + 3, + )?, + WorkspaceCoverageCurrentState::NeedsPreparation + )); + assert!( + authenticate_current_workspace_coverage_terminal_authority_with_store( + &runtime, + &authority.store, + )? + .is_none() + ); + let policy = WorkspaceCoveragePolicy::bounded_regular_files_v0( + WORKSPACE_COVERAGE_MAXIMUM_FILE_BYTES, + )?; + assert!( + observe_current_workspace_coverage_evidence_with_store( + &runtime, + &authority.store, + &basis, + &policy, + "provider", + "model", + 3, + &mut FakeProjectionPort::new(Hostility::Honest), + )? + .is_none() + ); + drop(authority); + assert!(current_workspace_coverage_recovery_target(&runtime)?.is_none()); + Ok(()) + } + + #[test] + fn retention_refuses_unknown_projection_rows_before_any_deletion() -> Result<()> { + let (repo, _state, runtime, mut basis) = coverage_fixture()?; + for generation in 1..=3 { + if generation > 1 { + std::fs::write( + repo.path().join("source.rs"), + format!("fn g{generation}() {{}}"), + )?; + basis = crate::observe_runtime_repository_body_basis(&runtime)?; + } + let (_, acquisition) = acquire_test(&runtime, &basis, "provider", "model", 3)?; + execute_preembedded_workspace_coverage_projection( + &acquisition, + projection_inputs(&acquisition, repo.path())?, + &mut FakeProjectionPort::new(Hostility::Honest), + )?; + drop(acquisition); + let authority = crate::open_workspace_coverage_authority(&runtime)?; + retire_workspace_coverage_collections(&authority, &mut FakeRetirementPort::default())?; + if generation == 3 { + let opening = authority.store.pull_all()?; + let evidence_env = opening + .iter() + .find(|entry| entry.r#type == COLLECTION_RETIREMENT_EVIDENCE_TYPE) + .expect("retirement evidence") + .clone(); + let mut substituted: WorkspaceCoverageCollectionRetirementEvidence = + decode(&evidence_env)?; + substituted.observed_result = "assumed-absent".into(); + let substituted_env = envelope( + COLLECTION_RETIREMENT_EVIDENCE_TYPE, + &evidence_env.key, + &substituted, + )?; + assert!( + authority + .store + .compare_and_swap_entry(&evidence_env, substituted_env.clone())? + ); + let before = authority.store.pull_all()?; + assert!(compact_workspace_coverage_history(&runtime, &authority).is_err()); + assert_eq!(authority.store.pull_all()?, before); + assert!( + authority + .store + .compare_and_swap_entry(&substituted_env, evidence_env)? + ); + + let malformed = CultCacheEnvelope { + r#type: CLAIM_TYPE.into(), + key: "malformed-known-row".into(), + schema_id: Some(CLAIM_SCHEMA.into()), + payload: vec![1, 2, 3], + stored_at: chrono::Utc::now().to_rfc3339(), + }; + assert!(authority.store.insert_entry_if_absent(malformed.clone())?); + let before = authority.store.pull_all()?; + assert!(compact_workspace_coverage_history(&runtime, &authority).is_err()); + assert_eq!(authority.store.pull_all()?, before); + assert!( + authority + .store + .delete_batch_if_unchanged(std::slice::from_ref(&malformed))? + ); + + let unknown = CultCacheEnvelope { + r#type: "gamecult.epiphany.workspace_coverage_alien".into(), + key: "current".into(), + schema_id: Some("alien.v0".into()), + payload: vec![1, 2, 3], + stored_at: chrono::Utc::now().to_rfc3339(), + }; + assert!(authority.store.insert_entry_if_absent(unknown)?); + let before = authority.store.pull_all()?; + assert!(compact_workspace_coverage_history(&runtime, &authority).is_err()); + assert_eq!(authority.store.pull_all()?, before); + } + drop(authority); + } + Ok(()) + } } diff --git a/epiphany-core/src/workspace_coverage_projector_service.rs b/epiphany-core/src/workspace_coverage_projector_service.rs index 4357ce0b..ddf35d4e 100644 --- a/epiphany-core/src/workspace_coverage_projector_service.rs +++ b/epiphany-core/src/workspace_coverage_projector_service.rs @@ -1,34 +1,23 @@ use crate::repository_body_observer::RepositoryBodyReadSession; use crate::semantic_backend::{OllamaConfig, OllamaEmbedder, QdrantBackend, QdrantConfig}; +use crate::workspace_coverage_process_documents::publish_workspace_coverage_terminal_sight; use crate::workspace_coverage_projector::{ WorkspaceCoverageAcquireResult, WorkspaceCoverageCurrentState, WorkspaceCoverageProjectionExecutionAuthority, acquire_workspace_coverage_projection, - classify_current_workspace_coverage, execute_workspace_coverage_projection, - prepare_workspace_coverage_projection, retire_workspace_coverage_collections, + classify_current_workspace_coverage, compact_workspace_coverage_history, + execute_workspace_coverage_projection, prepare_workspace_coverage_projection, + retire_workspace_coverage_collections, }; use crate::{ EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, HostIncarnationIdentityEntry, - load_current_runtime_repository_body_basis, runtime_repository_body_store_binding, + WorkspaceCoverageAuthority, load_current_runtime_repository_body_basis, + open_workspace_coverage_authority, runtime_repository_body_store_binding, }; use anyhow::{Context, Result, anyhow, bail}; use ed25519_dalek::SigningKey; -use sha2::{Digest, Sha256}; -#[cfg(windows)] -use std::ffi::OsStr; -#[cfg(unix)] -use std::fs::File; -#[cfg(unix)] -use std::os::fd::AsRawFd; -#[cfg(windows)] -use std::os::windows::ffi::OsStrExt; use std::path::{Path, PathBuf}; use uuid::Uuid; -#[cfg(windows)] -use windows_sys::Win32::Foundation::{CloseHandle, ERROR_ALREADY_EXISTS, GetLastError, HANDLE}; -#[cfg(windows)] -use windows_sys::Win32::System::Threading::{CreateMutexW, ReleaseMutex}; - const EMBEDDING_PROVIDER_ID: &str = "gamecult-ollama-embedding"; #[derive(Clone, Debug, PartialEq, Eq)] @@ -89,85 +78,8 @@ pub struct WorkspaceCoverageProjectorServicePulse { pub fault: Option, } -struct WorkspaceCoverageProjectorSingletonGuard { - #[cfg(windows)] - handle: HANDLE, - #[cfg(unix)] - file: File, -} - -impl Drop for WorkspaceCoverageProjectorSingletonGuard { - fn drop(&mut self) { - #[cfg(windows)] - unsafe { - let _ = ReleaseMutex(self.handle); - CloseHandle(self.handle); - } - #[cfg(unix)] - unsafe { - let _ = libc::flock(self.file.as_raw_fd(), libc::LOCK_UN); - } - } -} - -fn acquire_workspace_coverage_projector_singleton( - runtime_store: &Path, - body_store: &Path, -) -> Result { - let identity = format!( - "{:x}", - Sha256::digest( - format!( - "{}|{}", - runtime_store.to_string_lossy().to_lowercase(), - body_store.to_string_lossy().to_lowercase() - ) - .as_bytes() - ) - ); - #[cfg(windows)] - { - let name = OsStr::new(&format!( - "Global\\EpiphanyWorkspaceCoverageProjector-{identity}" - )) - .encode_wide() - .chain(std::iter::once(0)) - .collect::>(); - let handle = unsafe { CreateMutexW(std::ptr::null_mut(), 1, name.as_ptr()) }; - if handle.is_null() { - return Err(anyhow!( - "workspace coverage projector singleton mutex creation failed: {}", - unsafe { GetLastError() } - )); - } - if unsafe { GetLastError() } == ERROR_ALREADY_EXISTS { - unsafe { CloseHandle(handle) }; - bail!("workspace coverage projector owner already exists for this runtime Body route"); - } - return Ok(WorkspaceCoverageProjectorSingletonGuard { handle }); - } - #[cfg(unix)] - { - let path = - std::env::temp_dir().join(format!("epiphany-workspace-coverage-{identity}.lock")); - let file = File::options() - .create(true) - .read(true) - .write(true) - .open(path)?; - if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 { - bail!("workspace coverage projector owner already exists for this runtime Body route"); - } - return Ok(WorkspaceCoverageProjectorSingletonGuard { file }); - } - #[allow(unreachable_code)] - Err(anyhow!( - "workspace coverage projector singleton is unsupported on this platform" - )) -} - pub struct WorkspaceCoverageProjectorServiceBody { - _singleton: WorkspaceCoverageProjectorSingletonGuard, + coverage_authority: WorkspaceCoverageAuthority, runtime_store: PathBuf, executor_incarnation: String, managed_process_launch_id: String, @@ -220,9 +132,7 @@ impl WorkspaceCoverageProjectorServiceBody { "workspace coverage projector runtime Body route disagrees with authenticated runtime id" ); } - let body_store = PathBuf::from(route.body_store_path); - let singleton = - acquire_workspace_coverage_projector_singleton(&runtime_store, &body_store)?; + let coverage_authority = open_workspace_coverage_authority(&runtime_store)?; let operation_timeout_ms = config.qdrant_timeout_ms; let qdrant = QdrantBackend::new(QdrantConfig { url: config.qdrant_url, @@ -236,7 +146,7 @@ impl WorkspaceCoverageProjectorServiceBody { query_instruction: String::new(), })?; Ok(Self { - _singleton: singleton, + coverage_authority, runtime_store, executor_incarnation, managed_process_launch_id, @@ -304,12 +214,11 @@ impl WorkspaceCoverageProjectorServiceBody { } fn pulse_inner(&mut self) -> Result { - let route = runtime_repository_body_store_binding(&self.runtime_store)? - .ok_or_else(|| anyhow!("runtime has no repository Body-store binding"))?; // Retirement is derived from typed Body history and is deliberately // performed before the idle fast path. Qdrant never nominates its own // garbage and incompatible same-name collections stop the pulse. - retire_workspace_coverage_collections(&route.body_store_path, &mut self.qdrant)?; + retire_workspace_coverage_collections(&self.coverage_authority, &mut self.qdrant)?; + let _ = compact_workspace_coverage_history(&self.runtime_store, &self.coverage_authority)?; let basis = load_current_runtime_repository_body_basis(&self.runtime_store)?; // Tags are mutable. Re-resolve the installed artifact every pulse so a // same-dimensional model replacement cannot reuse an older index. @@ -318,12 +227,26 @@ impl WorkspaceCoverageProjectorServiceBody { if let WorkspaceCoverageCurrentState::Current(receipt) = classify_current_workspace_coverage( &self.runtime_store, + &self.coverage_authority.store, &basis, EMBEDDING_PROVIDER_ID, &embedding_model_identity, dimensions, )? { + let authority = self.execution_authority.as_ref().ok_or_else(|| { + anyhow!("workspace coverage projector has no installed execution authority") + })?; + publish_workspace_coverage_terminal_sight( + &authority.local_verse_store, + &self.runtime_store, + &self.coverage_authority, + &authority.runtime_id, + &self.managed_process_launch_id, + &authority.trusted_host, + &authority.provider_signing_key, + chrono::Utc::now(), + )?; return Ok(WorkspaceCoverageProjectorServicePulse { status: WorkspaceCoverageProjectorPulseStatus::Idle, body_observation_id: Some(basis.observation_id), @@ -343,6 +266,7 @@ impl WorkspaceCoverageProjectorServiceBody { let plan_id = prepared.plan.plan_id.clone(); match acquire_workspace_coverage_projection( &prepared, + &self.coverage_authority.store, EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID, &self.executor_incarnation, &self.managed_process_launch_id, @@ -358,6 +282,19 @@ impl WorkspaceCoverageProjectorServiceBody { }) } WorkspaceCoverageAcquireResult::Current(receipt) => { + let authority = self.execution_authority.as_ref().ok_or_else(|| { + anyhow!("workspace coverage projector has no installed execution authority") + })?; + publish_workspace_coverage_terminal_sight( + &authority.local_verse_store, + &self.runtime_store, + &self.coverage_authority, + &authority.runtime_id, + &self.managed_process_launch_id, + &authority.trusted_host, + &authority.provider_signing_key, + chrono::Utc::now(), + )?; Ok(WorkspaceCoverageProjectorServicePulse { status: WorkspaceCoverageProjectorPulseStatus::Idle, body_observation_id: Some(basis.observation_id), @@ -377,6 +314,8 @@ impl WorkspaceCoverageProjectorServiceBody { &self.embedder, &mut self.qdrant, &WorkspaceCoverageProjectionExecutionAuthority { + coverage_authority: &self.coverage_authority, + runtime_store: &self.runtime_store, local_verse_store: &authority.local_verse_store, runtime_id: &authority.runtime_id, trusted_host: &authority.trusted_host, @@ -447,18 +386,59 @@ mod tests { } #[test] - fn singleton_is_host_wide_for_one_canonical_runtime_body_pair() -> Result<()> { - let temp = tempfile::tempdir()?; - let runtime = temp.path().join("runtime.ccmp"); - let body = temp.path().join("body.ccmp"); - std::fs::write(&runtime, [])?; - std::fs::write(&body, [])?; - let runtime = runtime.canonicalize()?; - let body = body.canonicalize()?; - let first = acquire_workspace_coverage_projector_singleton(&runtime, &body)?; - assert!(acquire_workspace_coverage_projector_singleton(&runtime, &body).is_err()); + fn live_service_exclusively_owns_the_bound_coverage_store() -> Result<()> { + let state = tempfile::tempdir()?; + let repo = tempfile::tempdir()?; + let initialized = std::process::Command::new("git") + .arg("init") + .current_dir(repo.path()) + .output()?; + if !initialized.status.success() { + bail!("singleton fixture failed to initialize repository"); + } + let runtime = state.path().join("runtime.cc"); + let agents = state.path().join("agents.cc"); + let body = state.path().join("body.cc"); + let coverage = std::fs::canonicalize(state.path())?.join("workspace-coverage.cc"); + crate::initialize_runtime_spine( + &runtime, + crate::RuntimeSpineInitOptions { + runtime_id: "singleton-runtime".into(), + display_name: "singleton test".into(), + created_at: "2026-07-17T00:00:00Z".into(), + }, + )?; + crate::ensure_agent_memory_swarm_identity(&agents, "singleton-swarm")?; + crate::bind_runtime_to_agent_memory_swarm(&runtime, &agents, "2026-07-17T00:00:01Z")?; + crate::bind_repository_body(repo.path(), &body, &runtime, "singleton-workspace")?; + crate::bind_runtime_workspace_coverage_store(&runtime, &coverage, "2026-07-17T00:00:02Z")?; + let launch_id = "019bff10-7426-7a1c-9ce4-33f91660a3a7"; + let first = WorkspaceCoverageProjectorServiceBody::new( + &runtime, + "singleton-runtime", + config(), + "first-incarnation", + launch_id, + )?; + assert!( + WorkspaceCoverageProjectorServiceBody::new( + &runtime, + "singleton-runtime", + config(), + "second-incarnation", + launch_id, + ) + .is_err(), + "a second live projector must not acquire the same owned store" + ); drop(first); - assert!(acquire_workspace_coverage_projector_singleton(&runtime, &body).is_ok()); + WorkspaceCoverageProjectorServiceBody::new( + &runtime, + "singleton-runtime", + config(), + "replacement-incarnation", + launch_id, + )?; Ok(()) } } diff --git a/vendor/cultcache-rs b/vendor/cultcache-rs index d10471e6..24ea41e5 160000 --- a/vendor/cultcache-rs +++ b/vendor/cultcache-rs @@ -1 +1 @@ -Subproject commit d10471e6994c72a0bb6e8a6b2d60a578ccd1bde5 +Subproject commit 24ea41e569eca67373fe3ebd96cf3e4d524bd98d