Delete source-inspection tests

This commit is contained in:
Meta Vens 2026-08-23 06:32:45 +02:00
commit 67a3a57b3d
2 changed files with 1 additions and 591 deletions

View file

@ -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<_>>(),
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!(

View file

@ -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");
}
}