diff --git a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs index 8a161134..a69607db 100644 --- a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs +++ b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs @@ -3964,445 +3964,9 @@ mod service_lifecycle_brake_authority_tests { } #[cfg(test)] -mod semantic_projector_authority_tests { +mod workspace_coverage_recovery_tests { use super::*; - #[test] - fn supervisor_keeps_acquisition_inside_projector_and_selects_exact_recovery_evidence() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let issuer_flag = ["--issuer", "-incarnation"].concat(); - let executor_flag = ["--executor", "-incarnation"].concat(); - assert!(!source.contains(&issuer_flag)); - assert!(!source.contains(&executor_flag)); - let evidence_id_flag = ["--lifecycle", "-evidence-id"].concat(); - let evidence_hash_flag = ["--lifecycle", "-evidence-hash"].concat(); - assert!(!source.contains(&evidence_id_flag)); - assert!(!source.contains(&evidence_hash_flag)); - assert!(source.contains("--receipt-id")); - assert!(source.contains("--provider-heartbeat-id")); - let acquire_command = ["semantic", "-acquire"].concat(); - assert!(!source.contains(&acquire_command)); - assert!(source.contains("idunn_recover_memory_semantic_projection_from_cultmesh")); - assert!(source.contains("SEMANTIC_PROJECTOR_EXECUTOR_ID")); - let executor_id_flag = ["--executor", "-id"].concat(); - assert!(!source.contains(&executor_id_flag)); - } - - #[test] - fn recovery_command_only_rotates_claim_authority() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source.find("fn semantic_recover(args: Args)").unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn ").unwrap_or(tail.len()); - let body = &tail[..end]; - assert!(body.contains("idunn_recover_memory_semantic_projection_from_cultmesh")); - assert!(!body.contains("execute_memory_semantic_projection")); - assert!(!body.contains("MemorySemanticIndexConfig")); - } - - #[test] - fn managed_projector_policy_launches_one_modeling_process() { - let args = semantic_projector_service_args( - Path::new("modeling.ccmp"), - Path::new("local-verse.ccmp"), - "local-runtime", - 60, - "http://127.0.0.1:16333", - "http://10.77.0.1:11435", - "qwen3-embedding:0.6b", - ); - assert_eq!( - args, - vec![ - "serve", - "--runtime-store", - "modeling.ccmp", - "--local-verse-store", - "local-verse.ccmp", - "--runtime-id", - "local-runtime", - "--interval-seconds", - "60", - "--qdrant-url", - "http://127.0.0.1:16333", - "--ollama-base-url", - "http://10.77.0.1:11435", - "--ollama-model", - "qwen3-embedding:0.6b", - ] - ); - assert_eq!(args.iter().filter(|arg| arg.as_str() == "serve").count(), 1); - } - - #[test] - fn managed_workspace_coverage_projector_has_one_body_derived_runtime_input() { - let args = workspace_coverage_projector_service_args( - Path::new("runtime.ccmp"), - Path::new("local-verse.ccmp"), - "local-runtime", - 60, - "http://127.0.0.1:16333", - "http://10.77.0.1:11435", - "qwen3-embedding:0.6b", - ); - assert_eq!( - args, - vec![ - "serve", - "--runtime-store", - "runtime.ccmp", - "--local-verse-store", - "local-verse.ccmp", - "--runtime-id", - "local-runtime", - "--interval-seconds", - "60", - "--heartbeat-interval-seconds", - "10", - "--qdrant-url", - "http://127.0.0.1:16333", - "--ollama-base-url", - "http://10.77.0.1:11435", - "--ollama-model", - "qwen3-embedding:0.6b", - ] - ); - for forbidden in [ - "--agent-store", - "--body-store", - "--workspace", - "--collection", - "--dimensions", - ] { - assert!(!args.iter().any(|arg| arg == forbidden)); - } - } - - #[test] - fn reserved_projector_launch_seals_spawn_before_the_child_may_publish() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source.find("fn service_launch_internal(").unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn ").unwrap(); - let body = &tail[..end]; - let uuid = body.find("Uuid::new_v4()").unwrap(); - let env = body.find("EPIPHANY_STARTUP_LIFECYCLE_RECEIPT_ID").unwrap(); - let spawn = body.find(".spawn()").unwrap(); - let completion = body - .find("reserved_launch.as_ref().map(|_| Utc::now())") - .unwrap(); - let persist = body - .find("write_epiphany_cultmesh_daemon_service_lifecycle_receipt") - .unwrap(); - assert!(uuid < env && env < spawn && spawn < completion && completion < persist); - assert!(body.contains("receipt.managed_policy_digest = policy_digest")); - assert!(body.contains("receipt.startup_correlation_id = receipt_id")); - assert!(body.contains("let _ = child.kill()")); - assert!(body.contains("let _ = child.wait()")); - } - - #[test] - fn narrow_lifecycle_commands_read_only_the_swarm_brake_family() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - for function in [ - "managed_service_task_install", - "managed_service_task_operation", - "service_runbook", - ] { - let marker = format!("fn {function}("); - let start = source.find(&marker).unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn ").unwrap(); - let body = &tail[..end]; - assert!(body.contains("load_epiphany_cultmesh_swarm_brake")); - assert!(body.contains("assert_swarm_brake_allows_service_lifecycle_entry")); - assert!(!body.contains("query_epiphany_local_verse_context")); - } - } - - #[test] - fn policy_write_reads_only_the_exact_daemon_status_family() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source.find("fn write_policy(").unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn ").unwrap(); - let body = &tail[..end]; - assert!(body.contains("load_epiphany_cultmesh_daemon_status")); - assert!(!body.contains("query_epiphany_local_verse_context")); - } - - #[test] - fn direct_reconcile_reads_only_exact_status_policy_and_brake_families() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source.find("fn reconcile(").unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn ").unwrap(); - let body = &tail[..end]; - assert!(body.contains("load_epiphany_cultmesh_daemon_status")); - assert!(body.contains("load_policy_or_override")); - assert!(body.contains("load_epiphany_cultmesh_swarm_brake")); - assert!(!body.contains("query_epiphany_local_verse_context")); - } - - #[test] - fn workspace_coverage_launch_uses_only_specialized_process_authority() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source.find("fn service_launch_internal(").unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn ").unwrap(); - let body = &tail[..end]; - let env = body.find("EPIPHANY_WORKSPACE_COVERAGE_LAUNCH_ID").unwrap(); - let spawn = body.find(".spawn()").unwrap(); - let capture = body.find("capture_process_instance(child.id())").unwrap(); - let bootstrap = body - .find("write_workspace_coverage_process_bootstrap") - .unwrap(); - let persist = body - .find("write_workspace_coverage_managed_process_launch") - .unwrap(); - assert!(env < spawn && spawn < capture && capture < bootstrap && bootstrap < persist); - assert!(body.contains("open_default_host_identity")); - assert!(body.contains("native_boot_identity")); - assert!(body.contains("seed.zeroize()")); - assert!(body.contains("let _ = child.kill()")); - assert!(body.contains("let _ = child.wait()")); - } - - #[test] - fn workspace_coverage_reconcile_orders_termination_launch_readiness_and_body_transfer() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source - .find("fn reconcile_workspace_coverage_projector(") - .unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn service_runbook").unwrap(); - let body = &tail[..end]; - let latest = body - .find("load_latest_workspace_coverage_managed_process_launch") - .unwrap(); - let stale_rotation = body.find("if !current_policy_matches_latest").unwrap(); - let terminal_sight = body - .find( - "let terminal_sight = match authenticate_current_workspace_coverage_terminal_sight", - ) - .unwrap(); - let claim_sight = body - .find("let target = match authenticate_recovery_workspace_coverage_claim_sight") - .unwrap(); - assert!( - latest < stale_rotation - && stale_rotation < terminal_sight - && terminal_sight < claim_sight - ); - let observation = body - .rfind("let observation = match observe_workspace_coverage_managed_process") - .unwrap(); - let normal = &body[observation..]; - let alive = normal.find("status\": \"observed-alive").unwrap(); - let degraded = normal.find("status\": \"observation-degraded").unwrap(); - let termination_write = body - .rfind("write_workspace_coverage_process_termination_observation") - .unwrap(); - let termination = normal - .rfind("authenticate_workspace_coverage_termination_with_envelope_digest") - .unwrap(); - let launch = body.rfind("service_launch_internal").unwrap(); - let readiness = body - .rfind("load_latest_workspace_coverage_provider_heartbeat") - .unwrap(); - let recovery = body - .rfind("write_workspace_coverage_recovery_directive") - .unwrap(); - assert!( - alive - < normal - .find("write_workspace_coverage_process_termination_observation") - .unwrap() - ); - assert!( - degraded - < normal - .find("write_workspace_coverage_process_termination_observation") - .unwrap() - ); - assert!(termination_write < launch); - assert!(observation + termination < launch && launch < readiness && readiness < recovery); - assert!(body.contains("write_workspace_coverage_process_termination_observation")); - assert!(body.contains("status == \"ready\"")); - assert!(body.contains("authenticate_workspace_coverage_replacement_lineage")); - assert!(!body.contains("awaiting-exact-termination")); - assert!(!body.contains("open_workspace_coverage_authority")); - assert!(!body.contains("recover_workspace_coverage_projection")); - } - - #[test] - fn terminal_workspace_coverage_is_observed_without_recovery_authority() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source - .find( - "let terminal_sight = match authenticate_current_workspace_coverage_terminal_sight", - ) - .unwrap(); - let end = source[start..] - .find("let target = match authenticate_recovery_workspace_coverage_claim_sight") - .map(|offset| start + offset) - .unwrap(); - let branch = &source[start..end]; - let terminal_call = branch - .split_once("authenticate_current_workspace_coverage_terminal_sight(") - .map(|(_, tail)| tail) - .unwrap(); - assert_eq!( - terminal_call - .lines() - .take(3) - .map(str::trim) - .collect::>(), - vec!["", "&runtime_store,", "&args.store,"] - ); - let lineage = branch - .find("authenticate_workspace_coverage_replacement_lineage") - .unwrap(); - let observation = branch - .find("observe_workspace_coverage_managed_process") - .unwrap(); - let alive = branch.find("terminal-observer-alive").unwrap(); - let termination = branch - .find("write_workspace_coverage_process_termination_observation") - .unwrap(); - let restart = branch.find("service_launch_internal").unwrap(); - assert!(lineage < observation && observation < alive); - assert!(alive < termination && termination < restart); - assert!(!branch.contains("write_workspace_coverage_recovery_directive")); - assert!(!branch.contains("recover_workspace_coverage_projection")); - } - - #[test] - fn workspace_coverage_none_to_some_claim_race_uses_post_terminal_sight() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source - .find("fn reconcile_workspace_coverage_projector(") - .unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn service_runbook").unwrap(); - let body = &tail[..end]; - let termination = body - .rfind("authenticate_workspace_coverage_termination_with_envelope_digest") - .unwrap(); - let post_auth = body - .find("let post_terminal_target = match authenticate_recovery_workspace_coverage_claim_sight") - .unwrap(); - let replacement_selection = body.find("let existing_replacement =").unwrap(); - let post_target = body - .find("let Some(target) = post_terminal_target") - .unwrap(); - let directive = body - .find("write_workspace_coverage_recovery_directive") - .unwrap(); - assert!(termination < post_auth && post_auth < replacement_selection); - assert!(replacement_selection < post_target && post_target < directive); - assert!(body[post_auth..].contains("&target,")); - assert!( - body.contains("post-terminal claim sight does not name the terminated managed launch") - ); - } - - #[test] - fn workspace_coverage_reused_replacement_reports_observation_not_restart() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source - .find("fn reconcile_workspace_coverage_projector(") - .unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn service_runbook").unwrap(); - let body = &tail[..end]; - assert!(body.contains("(existing, false)")); - assert!(body.contains("replacement-observed-awaiting-claim")); - assert!(body.matches("\"restarted\": launched_now").count() >= 2); - } - - #[test] - fn workspace_coverage_launch_to_directive_crash_resumes_exact_replacement() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source - .find("fn reconcile_workspace_coverage_projector(") - .unwrap(); - let tail = &source[start..]; - let end = tail - .find("\nfn finish_workspace_coverage_recovery") - .unwrap(); - let body = &tail[..end]; - let mismatch = body.find("claim.launch_id != latest.launch_id").unwrap(); - let normal_observation = mismatch - + body[mismatch..] - .find("\n let observation = match observe_workspace_coverage_managed_process") - .unwrap(); - let branch = &body[mismatch..normal_observation]; - let replacement = branch - .find("let replacement = authenticate_workspace_coverage_managed_process_launch") - .unwrap(); - let lineage = branch - .find("authenticate_workspace_coverage_replacement_lineage") - .unwrap(); - let resume = branch - .find("return finish_workspace_coverage_recovery") - .unwrap(); - assert!(replacement < lineage && lineage < resume); - assert!(!branch.contains("replacement.policy_envelope_digest != old_launch")); - assert!(!branch.contains("service_launch_internal")); - - let finish = &source[source - .find("fn finish_workspace_coverage_recovery") - .unwrap()..]; - assert!(finish.contains("write_workspace_coverage_recovery_directive")); - assert!(finish.contains("\"restarted\": launched_now")); - } - - #[test] - fn workspace_coverage_stale_ready_missing_replacement_cannot_direct_or_mutate() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source - .find("fn reconcile_workspace_coverage_projector(") - .unwrap(); - let tail = &source[start..]; - let end = tail - .find("\nfn finish_workspace_coverage_recovery") - .unwrap(); - let body = &tail[..end]; - let mismatch = body.find("claim.launch_id != latest.launch_id").unwrap(); - let normal_observation = mismatch - + body[mismatch..] - .find("\n let observation = match observe_workspace_coverage_managed_process") - .unwrap(); - let branch = &body[mismatch..normal_observation]; - let replacement_sight = branch - .find("let replacement_observation = match observe_workspace_coverage_managed_process") - .unwrap(); - let alive_gate = branch - .find("WorkspaceCoverageProcessLifecycleObservation::ExactAlive") - .unwrap(); - let finish_call = branch - .find("return finish_workspace_coverage_recovery") - .unwrap(); - assert!(replacement_sight < alive_gate && alive_gate < finish_call); - assert!(branch.contains("WorkspaceCoverageProcessLifecycleObservation::Missing")); - assert!(branch.contains("\"replacement-terminal\"")); - assert!(branch.contains("\"observation-degraded\"")); - assert!(!branch.contains("write_workspace_coverage_process_termination_observation")); - assert!(!branch.contains("service_launch_internal")); - - let finish = &source[source - .find("fn finish_workspace_coverage_recovery") - .unwrap()..]; - let freshness = finish - .find("timestamp_is_fresh(&heartbeat.observed_at_utc)") - .unwrap(); - let directive = finish - .find("write_workspace_coverage_recovery_directive") - .unwrap(); - assert!(freshness < directive); - } - #[test] fn workspace_coverage_actuation_reobserves_after_readiness() -> Result<()> { let mut disappeared = std::collections::VecDeque::from([ @@ -4454,126 +4018,6 @@ mod semantic_projector_authority_tests { Ok(()) } - #[test] - fn reserved_projector_policy_has_no_generic_or_command_override_path() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let generic_start = source - .find("fn managed_service_policy(args: Args)") - .unwrap(); - let generic_tail = &source[generic_start..]; - let generic_end = generic_tail.find("\nfn ").unwrap(); - assert!(generic_tail[..generic_end].contains("SEMANTIC_PROJECTOR_SERVICE_ID")); - - let specialized_start = source - .find("fn semantic_projector_service_policy(mut args: Args)") - .unwrap(); - let specialized_tail = &source[specialized_start..]; - let specialized_end = specialized_tail.find("\nfn ").unwrap(); - let specialized = &specialized_tail[..specialized_end]; - assert!(specialized.contains("args.service_command.is_some()")); - assert!(specialized.contains("packaged_role_command_path(&args, \"semantic-projector\")")); - assert!(specialized.contains("write_managed_service_policy(args)")); - - let legacy_cli = include_str!("epiphany-memory-semantic.rs"); - let index_arm = ["\"index\"", " =>"].concat(); - let claim_flag = ["--claim", "-id"].concat(); - assert!(!legacy_cli.contains(&index_arm)); - assert!(!legacy_cli.contains(&claim_flag)); - } - - #[test] - fn windows_scm_commands_are_hard_refused_at_dispatch() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - for command in [ - "service-install-execute", - "service-reconcile", - "service-start", - "service-stop", - "service-execution-audit", - ] { - let dispatch = source - .find(&format!("\"{command}\"")) - .unwrap_or_else(|| panic!("missing legacy command {command}")); - let arm_tail = &source[dispatch - ..source[dispatch..] - .find('\n') - .map(|n| dispatch + n + 240) - .unwrap_or(source.len()) - .min(source.len())]; - assert!( - arm_tail.contains("refuse_false_windows_scm_authority"), - "{command} must terminate at the refusal gate" - ); - } - assert!(source.contains( - "this executable is a foreground console process, not a Windows service host" - )); - } - - #[test] - fn managed_service_task_definition_owns_foreground_idunn_lifecycle() { - let source = include_str!("epiphany-daemon-supervisor.rs"); - let start = source.find("fn managed_service_task_action").unwrap(); - let tail = &source[start..]; - let end = tail.find("\nfn managed_service_task_status").unwrap(); - let body = &tail[..end]; - for required in [ - "managed-service-serve", - "--release-id", - "--release-witness-sha256", - "pinned_packaged_release", - "New-ScheduledTaskTrigger -AtLogOn", - "LogonType Interactive", - "RunLevel Limited", - "MultipleInstances IgnoreNew", - "RestartCount", - "RestartInterval", - "ExecutionTimeLimit ([TimeSpan]::Zero)", - "StartWhenAvailable", - "AllowStartIfOnBatteries", - "DontStopIfGoingOnBatteries", - "-WorkingDirectory", - ] { - assert!( - body.contains(required), - "task definition missing {required}" - ); - } - assert!(!body.contains("sc.exe")); - assert!(body.contains("--service-command is forbidden")); - assert!(source.contains("let mut task_restart_count = 999_u32")); - assert!(source.contains("task_readback_has_drift")); - assert!(source.contains("\"install-drift\"")); - assert!(source.contains("\"in-sync\".to_string()")); - assert!(source.contains("managed-service-scheduler.fatal.log")); - assert!(source.contains("Resolve-TaskSid")); - 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/workspace_coverage_projector_service.rs b/epiphany-core/src/workspace_coverage_projector_service.rs index b31b7c62..280cadd6 100644 --- a/epiphany-core/src/workspace_coverage_projector_service.rs +++ b/epiphany-core/src/workspace_coverage_projector_service.rs @@ -413,27 +413,6 @@ mod tests { assert!(value.validate().is_err()); } - #[test] - fn terminal_authority_precedes_recovery_and_recovery_precedes_new_work() { - let source = include_str!("workspace_coverage_projector_service.rs"); - let start = source.find("fn pulse_inner(&mut self)").unwrap(); - let tail = &source[start..]; - let body = &tail[..tail.find("\n#[cfg(test)]").unwrap()]; - let directive = body - .find("authenticate_workspace_coverage_recovery_directive") - .unwrap(); - let recovery = body - .find("recover_workspace_coverage_projection_with_authority") - .unwrap(); - let retirement = body.find("retire_workspace_coverage_collections").unwrap(); - let classification = body.find("classify_current_workspace_coverage").unwrap(); - let new_work = body.find("RepositoryBodyReadSession::open").unwrap(); - assert!(retirement < classification); - assert!(classification < directive && directive < recovery); - assert!(recovery < new_work); - assert!(!body.contains("authenticate_current_workspace_coverage_claim_sight")); - } - #[test] fn constructor_requires_lifecycle_identity_before_touching_runtime() { assert!( @@ -513,17 +492,4 @@ mod tests { Ok(()) } - #[test] - fn acquired_claim_is_visible_before_any_projection_backend_work() { - let source = include_str!("workspace_coverage_projector_service.rs"); - let acquired = source - .find("WorkspaceCoverageAcquireResult::Acquired(acquisition)") - .unwrap(); - let body = &source[acquired..source.find("#[cfg(test)]").unwrap()]; - let sight = body - .find("publish_workspace_coverage_claim_sight(") - .unwrap(); - let execution = body.find("execute_workspace_coverage_projection(").unwrap(); - assert!(sight < execution, "claim sight must precede backend work"); - } }