diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs index 4355d5e0..f532f108 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -2612,6 +2612,26 @@ fn run_cli() -> Result<()> { }, )?; let service_overview = load_swarm_overview_report(&args)?; + let (service_health_readback, service_health_private_state_exposed) = + service_health_readback_from_idunn(&args)?; + let service_health_action_rows = service_health_readback["serviceActionRows"] + .as_array() + .context("service-health readback lost service action rows")?; + let service_health_action_tui_rows = service_health_readback["serviceActionTuiRows"] + .as_array() + .context("service-health readback lost service action TUI rows")?; + let service_health_diagnostic = format!( + "status={:?}, mode={:?}, command={:?}, attention={:?}, failed={:?}, missing={:?}, actions={}, privateHelper={}, privateJson={:?}", + service_health_readback["status"].as_str(), + service_health_readback["recommendedWrapperMode"].as_str(), + service_health_readback["recommendedWrapperCommand"].as_str(), + service_health_readback["serviceLifecycleAttentionCount"].as_u64(), + service_health_readback["serviceExecutionFailedCheckCount"].as_u64(), + service_health_readback["serviceExecutionMissingCheckCount"].as_u64(), + service_health_action_rows.len(), + service_health_private_state_exposed, + service_health_readback["privateStateExposed"].as_bool(), + ); let service_receipt_directory = { let context = query_epiphany_local_verse_context(&args.store, args.runtime_id.clone())?; @@ -2853,9 +2873,52 @@ fn run_cli() -> Result<()> { ) && row.contains("followUp=tools/epiphany_local_run.ps1 -Mode service-execution-readiness") }) + || service_health_readback["status"].as_str() != Some("attention") + || service_health_readback["recommendedWrapperMode"].as_str() + != Some("cluster-service-execution-audit") + || service_health_readback["recommendedWrapperCommand"].as_str() + != Some(WRAPPER_CLUSTER_SERVICE_EXECUTION_AUDIT_COMMAND) + || service_health_readback["serviceLifecycleAttentionCount"].as_u64() != Some(2) + || service_health_readback["serviceExecutionFailedCheckCount"].as_u64() + != Some(11) + || service_health_readback["serviceExecutionMissingCheckCount"].as_u64() + != Some(10) + || service_health_action_rows.len() != 4 + || service_health_private_state_exposed + || service_health_readback["privateStateExposed"].as_bool() != Some(false) + || !service_health_action_rows.iter().any(|row| { + row["family"].as_str() == Some("service-lifecycle") + && row["lifecycleOwner"].as_str() == Some(SERVICE_LIFECYCLE_OWNER) + && row["hostedBody"].as_str() == Some(SERVICE_LIFECYCLE_HOSTED_BODY) + && row["effectClass"].as_str() == Some("service-lifecycle-readback") + && row["mutatesState"].as_bool() == Some(false) + && row["requiresElevatedAuthority"].as_bool() == Some(false) + && row["serviceExecutionFailedCheckCount"].as_u64() == Some(5) + && row["privateStateExposed"].as_bool() == Some(false) + }) + || !service_health_action_rows.iter().any(|row| { + row["family"].as_str() == Some("service-execution-authority") + && row["lifecycleOwner"].as_str() == Some(SERVICE_LIFECYCLE_OWNER) + && row["hostedBody"].as_str() == Some(SERVICE_LIFECYCLE_HOSTED_BODY) + && row["effectClass"].as_str() == Some("elevated-service-control") + && row["mutatesState"].as_bool() == Some(true) + && row["requiresElevatedAuthority"].as_bool() == Some(true) + && row["operatorAftercareCommand"].as_str() + == Some(WRAPPER_CLUSTER_SERVICE_EXECUTION_AUDIT_COMMAND) + && row["serviceExecutionFailedCheckCount"].as_u64() == Some(5) + && row["privateStateExposed"].as_bool() == Some(false) + }) + || !service_health_action_tui_rows.iter().any(|row| { + row.as_str().is_some_and(|row| { + row.contains("service-lifecycle") + && row.contains("owner=Idunn") + && row.contains("hostedBody=Epiphany") + && row.contains("failedChecks=5") + }) + }) { anyhow::bail!( - "local Verse query smoke did not expose sealed service lifecycle readback plus cluster and service execution failed-check anatomy" + "local Verse query smoke did not expose sealed Idunn-owned service lifecycle readback plus service-health payload anatomy: {service_health_diagnostic}" ); } let readiness_follow_up_receipt = EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry { @@ -6040,48 +6103,7 @@ fn run_invoke_tool_command(args: &Args) -> Result<()> { .unwrap_or(host_cluster_from_directory); let (service_health_readback, service_health_readback_private_state_exposed) = if is_service_health_capability(capability) { - let overview = load_swarm_overview_report(args)?; - let service_action_rows = overview - .swarm_action_rows - .iter() - .filter(|row| { - row.family == "service-lifecycle" || row.family == "service-execution-authority" - }) - .cloned() - .collect::>(); - let service_action_tui_rows = service_action_rows - .iter() - .map(swarm_action_tui_row) - .collect::>(); - let private_state_exposed = overview - .service_lifecycle_attention_rows - .iter() - .any(|row| row.private_state_exposed) - || overview - .service_execution_failed_check_rows - .iter() - .any(|check| !check.private_state_sealed) - || service_action_rows - .iter() - .any(|row| row.private_state_exposed); - ( - json!({ - "status": overview.recovery_status, - "recommendedWrapperMode": overview.service_lifecycle_recommended_wrapper_mode, - "recommendedWrapperCommand": overview.service_lifecycle_recommended_wrapper_command, - "serviceLifecycleAttentionCount": overview.service_lifecycle_attention_rows.len(), - "serviceLifecycleAttentionRows": overview.service_lifecycle_attention_rows, - "serviceLifecycleAttentionTuiRows": overview.service_lifecycle_attention_tui_rows, - "serviceExecutionFailedCheckCount": overview.service_execution_failed_check_count, - "serviceExecutionMissingCheckCount": overview.service_execution_missing_check_count, - "serviceExecutionFailedCheckRows": overview.service_execution_failed_check_rows, - "serviceExecutionFailedCheckTuiRows": overview.service_execution_failed_check_tui_rows, - "serviceActionRows": service_action_rows, - "serviceActionTuiRows": service_action_tui_rows, - "privateStateExposed": private_state_exposed, - }), - private_state_exposed, - ) + service_health_readback_from_idunn(args)? } else { (serde_json::Value::Null, false) }; @@ -6160,6 +6182,51 @@ fn default_daemon_tool_receipt_status( } } +fn service_health_readback_from_idunn(args: &Args) -> Result<(serde_json::Value, bool)> { + let overview = load_swarm_overview_report(args)?; + let service_action_rows = overview + .swarm_action_rows + .iter() + .filter(|row| { + row.family == "service-lifecycle" || row.family == "service-execution-authority" + }) + .cloned() + .collect::>(); + let service_action_tui_rows = service_action_rows + .iter() + .map(swarm_action_tui_row) + .collect::>(); + let private_state_exposed = overview + .service_lifecycle_attention_rows + .iter() + .any(|row| row.private_state_exposed) + || overview + .service_execution_failed_check_rows + .iter() + .any(|check| !check.private_state_sealed) + || service_action_rows + .iter() + .any(|row| row.private_state_exposed); + Ok(( + json!({ + "status": overview.recovery_status, + "recommendedWrapperMode": overview.service_lifecycle_recommended_wrapper_mode, + "recommendedWrapperCommand": overview.service_lifecycle_recommended_wrapper_command, + "serviceLifecycleAttentionCount": overview.service_lifecycle_attention_rows.len(), + "serviceLifecycleAttentionRows": overview.service_lifecycle_attention_rows, + "serviceLifecycleAttentionTuiRows": overview.service_lifecycle_attention_tui_rows, + "serviceExecutionFailedCheckCount": overview.service_execution_failed_check_count, + "serviceExecutionMissingCheckCount": overview.service_execution_missing_check_count, + "serviceExecutionFailedCheckRows": overview.service_execution_failed_check_rows, + "serviceExecutionFailedCheckTuiRows": overview.service_execution_failed_check_tui_rows, + "serviceActionRows": service_action_rows, + "serviceActionTuiRows": service_action_tui_rows, + "privateStateExposed": private_state_exposed, + }), + private_state_exposed, + )) +} + fn default_daemon_tool_result_ref( capability: &EpiphanyCultMeshDaemonToolCapabilityEntry, receipt_id: &str, diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index ad60fba9..e0757e9e 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -41,7 +41,7 @@ remembers doctrine; the branch remembers the blade. - This Codex operator's own roadmap/todo posture has been retuned for this scale target, with the Epiphany Imagination specialist as an optional sub-agent rail rather than the whole point. `notes/epiphany-investor-readiness-roadmap.md` now says: make the local Mom MVP a repeatable proof bundle; build the Bifrost-first external-work bridge; add compute/review/accepted-artifact accounting; prove fresh-repo operation without supervisor contamination; keep public/operator-safe exports sealed; and treat angel capital as fuel for capacity, not command authority. The Imagination specialist prompt was also updated so investor-scale Objective Drafts must name Bifrost provenance, bounded Epiphany proof, maintainer review, receipts/ledger evidence, compute/output metrics, public/private export safety, consent, and legal/security gates. - Local operator status runs now write typed CultMesh operator witnesses into `.epiphany-run/cultmesh/local-verse.ccmp`: `epiphany-operator-run` records the run intent before acting, `epiphany-operator-snapshot` distills the operator-safe MVP status artifact, and `epiphany-operator-run` records the completion receipt after success. The final `local-verse-context.json` is queried after those witnesses exist, so the operator read path sees latest run intent, snapshot, and receipt from the same local Verse vessel instead of treating separate JSON artifacts or side stores as truth. - `epiphany-operator-snapshot from-status` also mirrors the latest native status `tools.invocations[]` row into the same local Verse as `epiphany.cultmesh.daemon_tool_invocation_intent.v0`, plus `epiphany.cultmesh.daemon_tool_invocation_receipt.v0` when runtime-spine has a receipt id. Runtime-spine remains the tool lifecycle owner and raw MCP JSON stays quarantined behind `epiphany.tool_invocation_intent.v0` / `epiphany.tool_invocation_receipt.v0`; the local Verse mirror is operator-safe routing/readback. -- `epiphany-verse-query invoke-tool --capability-id ` now exercises the same global daemon tool directory directly: it records a typed daemon tool invocation intent plus receipt from an advertised capability and reports requesting/host display names, body domains, private Verse ids, and Eve surfaces from cluster topology, while the target daemon remains the execution owner and private Verse payloads stay sealed. `tools/epiphany_local_run.ps1 -Mode tool-invoke` wraps that same receipt path with explicit capability/requester/intent/receipt parameters, so operator use follows the same daemon-owned contract instead of a wrapper-owned shortcut. Tool routing reads the target daemon's typed liveness status and refuses when the host daemon is not `ready` or does not advertise `submitTypedToolIntent`. `epiphany-verse-query daemon-status --daemon-id --daemon-status ready|down|degraded` updates one daemon's status without repainting the whole status table, and local Verse seeding preserves existing daemon statuses and swarm-brake state instead of overwriting live telemetry. The CLI proof used Persona requesting Hands `repo-action` through `epiphany.cluster.hands.tool.repo-action`, returned Persona/Hands topology metadata, and refused the same invocation when Hands was degraded; the wrapper proof used stable ids `daemon-tool-intent-wrapper-persona-hands` / `daemon-tool-receipt-wrapper-persona-hands` and returned `availableToAllAgents=true`, `requiresReceipt=true`, and `privateStateExposed=false`. The invocation command body is now extracted out of the monolithic CLI `main` so compact row work does not tip the Windows debug stack; live wrapper artifact `local-20260618-181426-520-e3b051b8` routed Persona to Hands `repo-action` and printed one compact `INVOKE` row with requester/host private Verses, Eve surfaces, host daemon id, operation, capability, intent, receipt/status, authority, all-agents, receipt-required, and `private=false`. The Self-hosted `service-health` tool now embeds `serviceHealthReadback` in the invocation JSON, carrying Idunn service lifecycle attention rows, service action rows, failed-check rows, and private-state seals from the same local Verse; wrapper proof `local-20260619-013750-366-f5ad69b0` printed `serviceHealth=status=attention:attentionRows=2:actionRows=4:failedChecks=11:missingChecks=0:private=False`. +- `epiphany-verse-query invoke-tool --capability-id ` now exercises the same global daemon tool directory directly: it records a typed daemon tool invocation intent plus receipt from an advertised capability and reports requesting/host display names, body domains, private Verse ids, and Eve surfaces from cluster topology, while the target daemon remains the execution owner and private Verse payloads stay sealed. `tools/epiphany_local_run.ps1 -Mode tool-invoke` wraps that same receipt path with explicit capability/requester/intent/receipt parameters, so operator use follows the same daemon-owned contract instead of a wrapper-owned shortcut. Tool routing reads the target daemon's typed liveness status and refuses when the host daemon is not `ready` or does not advertise `submitTypedToolIntent`. `epiphany-verse-query daemon-status --daemon-id --daemon-status ready|down|degraded` updates one daemon's status without repainting the whole status table, and local Verse seeding preserves existing daemon statuses and swarm-brake state instead of overwriting live telemetry. The CLI proof used Persona requesting Hands `repo-action` through `epiphany.cluster.hands.tool.repo-action`, returned Persona/Hands topology metadata, and refused the same invocation when Hands was degraded; the wrapper proof used stable ids `daemon-tool-intent-wrapper-persona-hands` / `daemon-tool-receipt-wrapper-persona-hands` and returned `availableToAllAgents=true`, `requiresReceipt=true`, and `privateStateExposed=false`. The invocation command body is now extracted out of the monolithic CLI `main` so compact row work does not tip the Windows debug stack; live wrapper artifact `local-20260618-181426-520-e3b051b8` routed Persona to Hands `repo-action` and printed one compact `INVOKE` row with requester/host private Verses, Eve surfaces, host daemon id, operation, capability, intent, receipt/status, authority, all-agents, receipt-required, and `private=false`. The Self-hosted `service-health` tool now embeds `serviceHealthReadback` in the invocation JSON, carrying Idunn service lifecycle attention rows, service action rows, failed-check rows, and private-state seals from the same local Verse; production and smoke share `service_health_readback_from_idunn`, and source smoke now rejects any payload that loses Idunn owner/hosted-body fields, service lifecycle/action rows, failed-check anatomy, or the private-state seal. Live wrapper proof `local-20260619-015010-170-38e1c830` printed `serviceHealth=status=attention:attentionRows=2:actionRows=4:failedChecks=11:missingChecks=0:private=False`. - `epiphany-verse-query swarm-overview` and `epiphany-verse-query swarm-triage` now publish direct and wrapper command hints for the compact operator paths: topology, liveness, surfaces, tool directory, receipt directory, poke-down, Eve connection, Bifrost ledger readback, and `wrapperInvokeTool=tools/epiphany_local_run.ps1 -Mode tool-invoke -ToolCapabilityId -ToolRequestingAgentId -ToolRequestingClusterId `. The hints are display/ergonomics only; daemon-hosted tool invocation still routes through the typed intent/receipt path and host-daemon liveness gate, Bifrost ledger readback still reads Bifrost/Imagination-owned receipts, and receipt directory readback only indexes latest sealed local Verse witnesses. - `epiphany-daemon-supervisor policy --daemon-id --restart-command [--restart-arg ...]` writes durable local Verse restart policy as `epiphany.cultmesh.daemon_restart_policy.v0` with command/args/cwd/cooldown/backoff/attempt state, reconcile cadence, stale-heartbeat threshold, and last scheduled pulse. `epiphany-daemon-supervisor reconcile --daemon-id ` loads that policy when no override command is supplied, refuses under a matching `daemon.lifecycle_poke` brake before launching anything, refuses during cooldown/backoff, writes daemon poke intent/receipt documents, updates daemon status to `ready` or `down` from the command exit, and updates policy attempt state. `epiphany-daemon-supervisor tick [--daemon-id ]` is an explicit scheduler pulse: it scans durable policies, records ready/noop pulses, skips before the configured interval, marks stale heartbeat status degraded, routes restarts through the same brake/cooldown/poke receipt path, and writes latest `epiphany.cultmesh.daemon_scheduler_receipt.v0`. `epiphany-daemon-supervisor serve` runs that same pulse on `--loop-interval-seconds`, with bounded `--max-iterations` proof mode or unbounded service mode. `epiphany-daemon-supervisor service-plan`/`install-service` writes a planned local Verse `epiphany.cultmesh.daemon_service_lifecycle_receipt.v0` for the `serve` command; `service-launch`/`start-service` spawns that loop through the current executable or `--service-command`, can `--wait-child` for bounded proof, and records command/args/cwd, scheduler id, daemon selector, pid/exit/status, artifact ref, and private-state guard; `service-runbook` writes a PowerShell operator runbook artifact for the same `serve` command and records it as a lifecycle receipt without spawning; `windows-service-install`/`service-install-plan` writes a Windows `sc.exe create` install script for that same `serve` command and records a lifecycle receipt, with optional `--execute-install` reserved for explicit elevated authority; `windows-service-status`, `windows-service-reconcile`, `windows-service-execution-readiness`, `windows-service-execution-audit`, `windows-service-execution-runbook`, `windows-service-start`, and `windows-service-stop` query/request/audit/document the Windows service manager path and record lifecycle receipts for missing/running/stopped/query-failed, in-sync/drift/missing/query-failed, elevated-ready/not-elevated, complete/incomplete, runbook written, start/stop planned, execution-refused-not-elevated, or start/stop requested/failed outcomes. `tools/epiphany_local_run.ps1 -Mode service-runbook`, `-Mode service-install-plan`, `-Mode service-install-execute`, `-Mode service-status`, `-Mode service-reconcile`, `-Mode service-execution-readiness`, `-Mode service-execution-runbook`, `-Mode service-execution-audit`, `-Mode service-start-plan`, `-Mode service-stop-plan`, `-Mode service-start-execute`, and `-Mode service-stop-execute` wrap the artifact/status/reconcile/readiness/runbook/audit/control-plan/execution paths with operator run intent/receipt and final local Verse context. Service lifecycle actions check the local Verse swarm brake before spawning, writing runbook/install artifacts, querying service-manager state, reconciling service policy, checking execution readiness, auditing execution receipts, planning control, or requesting start/stop. The local wrapper builds/checks this binary with the other Epiphany operator tools. Installed-service status reconciliation has now been proved read-only against the real Windows `EventLog` service: `service-status` wrote `daemon-service-lifecycle-receipt-windows-eventlog-proof-windows-service-status` with status `running`, exit code `0`, and `privateStateExposed=false`. The new read-only policy reconciliation path was also proved: direct missing-service reconcile wrote `missing`, direct real-service reconcile wrote `drift`, brake engagement refused before query with exit `1`, and wrapper `service-reconcile` wrote `daemon-service-lifecycle-receipt-windows-eventlog-reconcile-proof-windows-service-reconcile` with status `drift`, exit code `0`, artifact ref `service-manager://windows/EventLog/reconcile`, and `privateStateExposed=false`. Start/stop now plan by default unless `--execute-control`/`--execute-service-control` is passed: direct start/stop wrote `start-planned`/`stop-planned` with `executed=false`, wrapper `service-start-plan` and `service-stop-plan` wrote local Verse receipts against `EventLog`, and brake engagement refused the plan path before any control action. Explicit execution is also elevation-gated before mutation: non-elevated `--execute-control` and `--execute-install` wrote `execution-refused-not-elevated` lifecycle receipts with `executed=false`, and a matching brake still refuses before the elevation check. Execution readiness is queryable without mutation: direct and wrapper `windows-service-execution-readiness` wrote `not-elevated` receipts for `EventLog`, with `privateStateExposed=false`, and brake engagement refused readiness as lifecycle activity. The explicit wrapper execution modes have also been proved in this non-elevated shell: `service-install-execute`, `service-start-execute`, and `service-stop-execute` reached the elevation gate, wrote `execution-refused-not-elevated` receipts, and did not mutate Windows services. Execution audit is now the post-run proof target: it scans service lifecycle receipts through CultMesh typed enumeration, writes its own audit receipt, and returns `complete` only when the sealed `windows-service-execution-runbook` witness plus elevated-ready/install/start/status/reconcile/stop effect receipts are present, successful, and sealed. Audit check rows carry `operatorArtifactRef`, and wrapper audit summaries print OK runbook witnesses with local SHA-256 before failed checks. Focused test `service_execution_audit_checks_expose_operator_artifact_refs` proves the typed field; live cluster wrapper proof `local-20260618-170322-330-e6cb2117` printed the cluster runbook witness hash while still reporting the five expected failed checks. This is a durable policy-backed process-owner seam; the remaining scar is an actual elevated install/start/stop execution proof under operator authority followed by a `complete` audit receipt. - `tools/epiphany_local_run.ps1 -Mode service-execution-runbook` writes a non-mutating `#Requires -RunAsAdministrator` PowerShell artifact that sequences `service-execution-readiness`, `service-install-execute`, `service-start-execute`, `service-status`, `service-reconcile`, `service-stop-execute`, final `service-status`, and `service-execution-audit` through the existing typed wrapper modes, then asks `epiphany-daemon-supervisor windows-service-execution-runbook` to seal the artifact as a `written` lifecycle receipt. The artifact now uses `Invoke-EpiphanyRunbookStep` so each step resets `$LASTEXITCODE`, catches thrown/nonzero failures, keeps running to gather more lifecycle receipts, runs `service-execution-audit` in `finally`, and exits nonzero only after the audit if any step failed. Latest proof `local-20260618-160641-685-331af57c` generated and parsed the artifact with `privateStateExposed=false`; the next elevated scar is to run it under explicit operator authority and preserve its effect receipts. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 749f1f73..0caf349f 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 51dcddad..5824f5df 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -123,7 +123,7 @@ active_subgoals: accepted_design: - Distributed Epiphany dreaming is a CultMesh typed-document problem, not prompt folklore. CultCache owns local typed documents, Epiphany owns export/import/adoption policy, CultNet owns wire/provenance/shard delivery, and CultMesh owns Verses, peer exchange, leases, shard logs, replicas, and watchable runtime surfaces. Start with local dream document types and a local store before public Verse wiring. - - The local CultMesh daemon tool directory now has both discovery and invocation receipts at the operator edge. `epiphany-verse-query tools` lists globally available, receipt-gated daemon capabilities; `epiphany-verse-query invoke-tool --capability-id ` records `epiphany.cultmesh.daemon_tool_invocation_intent.v0` plus `epiphany.cultmesh.daemon_tool_invocation_receipt.v0` from the advertised capability, reports requesting/host display names, body domains, private Verse ids, and Eve surfaces from cluster topology, and refuses when the host daemon is not ready. `tools/epiphany_local_run.ps1 -Mode tool-invoke` wraps the same path with explicit requester/capability/intent/receipt parameters; wrapper proof routed Persona to Hands `repo-action` and returned `availableToAllAgents=true`, `requiresReceipt=true`, and `privateStateExposed=false`. Tool availability is global across local agents, but execution and authority remain with the hosting daemon and its typed receipt contract. The Self-hosted `service-health` tool now embeds `serviceHealthReadback` in the invocation result instead of only pointing at receipt-directory: live wrapper proof `local-20260619-013750-366-f5ad69b0` returned status `attention`, two service lifecycle attention rows, four service action rows, eleven failed checks, zero missing checks, and no private-state exposure. + - The local CultMesh daemon tool directory now has both discovery and invocation receipts at the operator edge. `epiphany-verse-query tools` lists globally available, receipt-gated daemon capabilities; `epiphany-verse-query invoke-tool --capability-id ` records `epiphany.cultmesh.daemon_tool_invocation_intent.v0` plus `epiphany.cultmesh.daemon_tool_invocation_receipt.v0` from the advertised capability, reports requesting/host display names, body domains, private Verse ids, and Eve surfaces from cluster topology, and refuses when the host daemon is not ready. `tools/epiphany_local_run.ps1 -Mode tool-invoke` wraps the same path with explicit requester/capability/intent/receipt parameters; wrapper proof routed Persona to Hands `repo-action` and returned `availableToAllAgents=true`, `requiresReceipt=true`, and `privateStateExposed=false`. Tool availability is global across local agents, but execution and authority remain with the hosting daemon and its typed receipt contract. The Self-hosted `service-health` tool now embeds `serviceHealthReadback` in the invocation result instead of only pointing at receipt-directory: live wrapper proof `local-20260619-013750-366-f5ad69b0` returned status `attention`, two service lifecycle attention rows, four service action rows, eleven failed checks, zero missing checks, and no private-state exposure. Production invocation and source smoke now share `service_health_readback_from_idunn`, and the smoke rejects payloads that lose Idunn ownership, service lifecycle/action rows, failed-check anatomy, or the private-state seal. - The local Verse swarm brake is now operator-writable from the same CLI surface and enforced at the main local wrapper plus direct coordinator/heartbeat runner edges. `epiphany-verse-query swarm-brake --brake-status engaged|released` writes the typed `epiphany.cultmesh.swarm_brake.v0` document with scope, reason, operator id, affected clusters, protected surfaces, expiry, and private-state seal. `tools/epiphany_local_run.ps1` queries that document before live `plan`, `run`, or `mvp` work and fails closed when engaged; `status` remains readable. `epiphany-mvp-coordinator --local-verse-store ` refuses before app-server startup when the brake is engaged, and `epiphany-heartbeat-store tick|pump|heat|queue-mention|routine --local-verse-store ` refuses heartbeat-driving work while leaving init/status/complete/repair-stale outside that live-run brake. - The first Rust CultMesh integration slice is landed and repaired to compile from repo-contained vendored crates. `vendor/cultmesh-rs` is a small Rust node/database facade over vendored CultCache and CultNet with document-set registration and durable typed put/get/delete. `vendor/cultcache-rs` now reads and writes the `cultcache.store.v1` snapshot format used by `state/ledgers.msgpack`, so `epiphany-state status` is a working re-entry rite again. `epiphany-core` depends on `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`, exposes an `EpiphanyCultMeshStatusEntry`, records typed `EpiphanyCultMeshVersePolicyEntry` documents for the internal/local-area/global Verse tiers, and records typed `EpiphanyCultMeshGlobalRoomPolicyEntry` documents for threaded public global rooms such as dreams, architecture, research, Personas, GameCult, and governance. Native operator status is now a typed `EpiphanyCultMeshOperatorStatusEntry` in the internal Verse; it names Codex as bridge transport, Epiphany as authority owner, prompt-authority separation, and the quarantined Rider/Unity optional surfaces. Native operator snapshots are typed `EpiphanyCultMeshOperatorSnapshotEntry` documents distilled from operator-safe status artifacts; local status runs write operator run intent, operator snapshot, and run receipt into `.epiphany-run/cultmesh/local-verse.ccmp`, leaving JSON artifacts as display/evidence rather than the local-run read authority. - Mind's CultNet contract surface is native enough for the next Aquarium/CultMesh cut: `epiphany-core::mind_gateway` defines thought, state-effect proposal, gateway-review, commit-receipt, rejection-receipt, and Verse-adoption document contracts; runtime-spine advertises those mutation/read contracts; CultMesh persists matching `EpiphanyCultMeshMindContractEntry` policy documents so the private state guardian boundary is inspectable as typed state.