From bc692409b8a3deb4b9e0cddca05851062a64dfe1 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 19 Jun 2026 03:27:53 +0100 Subject: [PATCH] Advertise swarm online runbook tool --- epiphany-core/src/bin/epiphany-verse-query.rs | 210 ++++++++++++++++-- epiphany-core/src/cultmesh_integration.rs | 36 ++- notes/fresh-workspace-handoff.md | 8 +- state/ledgers.msgpack | Bin 295817 -> 296377 bytes state/map.yaml | 4 +- tools/epiphany_local_run.ps1 | 6 +- 6 files changed, 236 insertions(+), 28 deletions(-) diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs index 1c3108c6..6b752a41 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -1481,7 +1481,7 @@ fn run_cli() -> Result<()> { { anyhow::bail!("local Verse query smoke lost Eve connection intent/receipt"); } - if context.daemon_tool_capabilities.len() < 16 { + if context.daemon_tool_capabilities.len() < 18 { anyhow::bail!("local Verse query smoke expected daemon tool capabilities"); } if !context.daemon_tool_capabilities.iter().all(|capability| { @@ -1496,7 +1496,7 @@ fn run_cli() -> Result<()> { let tool_directory = load_epiphany_cultmesh_daemon_tool_directory(&args.store, args.runtime_id.clone())?; let tool_report = daemon_tool_directory_report(&tool_directory); - if tool_report.rows.len() < 16 || tool_report.host_attention_count != 0 { + if tool_report.rows.len() < 18 || tool_report.host_attention_count != 0 { anyhow::bail!( "local Verse query smoke expected globally visible tools hosted by ready daemons" ); @@ -1534,6 +1534,23 @@ fn run_cli() -> Result<()> { "local Verse query smoke lost compact Self service-health tool contract row" ); } + if !tool_report.tui_rows.iter().any(|row| { + row.contains("READY") + && row.contains("Self") + && row.contains("swarm-online-runbook") + && row.contains("epiphany.cluster.self.tool.swarm-online-runbook") + && row.contains("authority=daemon.service_lifecycle") + && row.contains("input=epiphany.cultmesh.daemon_service_online_runbook_request") + && row + .contains("receiptType=epiphany.cultmesh.daemon_service_lifecycle_receipt") + && row.contains("allAgents=true") + && row.contains("receipt=true") + && row.contains("private=false") + }) { + anyhow::bail!( + "local Verse query smoke lost compact Self swarm-online-runbook tool contract row" + ); + } if DIRECT_INVOKE_TOOL_COMMAND != "epiphany-verse-query invoke-tool --capability-id " || !WRAPPER_INVOKE_TOOL_COMMAND.contains("-Mode tool-invoke") @@ -1559,7 +1576,7 @@ fn run_cli() -> Result<()> { || topology_report.daemon_count != 7 || overview_surface_report.rows.len() != 7 || overview_surface_report.public_discussion_count != 1 - || overview_tool_report.rows.len() < 16 + || overview_tool_report.rows.len() < 18 || overview_tool_report.host_attention_count != 0 { anyhow::bail!("local Verse query smoke lost compact swarm overview invariants"); @@ -1900,6 +1917,61 @@ fn run_cli() -> Result<()> { "local Verse query smoke lost service-health daemon tool readback route" ); } + let swarm_online_runbook = context + .daemon_tool_capabilities + .iter() + .find(|capability| { + capability.capability_id == "epiphany.cluster.self.tool.swarm-online-runbook" + }) + .context("missing Self swarm-online-runbook daemon tool capability")?; + let swarm_online_runbook_receipt_status = + default_daemon_tool_receipt_status(swarm_online_runbook); + let swarm_online_runbook_result_ref = default_daemon_tool_result_ref( + swarm_online_runbook, + "daemon-tool-receipt-swarm-online-runbook-smoke", + ); + let swarm_online_runbook_row = + daemon_tool_invocation_tui_row(DaemonToolInvocationTuiFields { + requester: "Persona", + requesting_agent_id: "epiphany.Persona", + requesting_private_verse: "epiphany.cluster.persona.private", + requesting_surface: "eve://epiphany/persona", + host: "Self", + host_daemon_id: &swarm_online_runbook.host_daemon_id, + host_private_verse: "epiphany.cluster.self.private", + host_surface: "eve://epiphany/self", + capability_id: &swarm_online_runbook.capability_id, + tool_name: &swarm_online_runbook.tool_name, + operation: &swarm_online_runbook.operation, + intent_id: "daemon-tool-intent-swarm-online-runbook-smoke", + receipt_id: "daemon-tool-receipt-swarm-online-runbook-smoke", + receipt_status: &swarm_online_runbook_receipt_status, + receipt_contract_type: &swarm_online_runbook.receipt_contract_type, + result_ref: &swarm_online_runbook_result_ref, + authority_gate: &swarm_online_runbook.authority_gate, + all_agents: swarm_online_runbook.available_to_all_agents, + requires_receipt: swarm_online_runbook.requires_receipt, + private_state_exposed: false, + }); + if !swarm_online_runbook_row.contains("tool=swarm-online-runbook") + || !swarm_online_runbook_row.contains("host=Self") + || !swarm_online_runbook_row.contains("operation=prepareSwarmOnlineRunbook") + || !swarm_online_runbook_row + .contains("receiptStatus=accepted-for-swarm-online-runbook-readback") + || !swarm_online_runbook_row + .contains("receiptType=epiphany.cultmesh.daemon_service_lifecycle_receipt") + || !swarm_online_runbook_row.contains( + "resultRef=cultmesh://epiphany-local/daemon-service-lifecycle/swarm-online-runbook", + ) + || !swarm_online_runbook_row.contains("authority=daemon.service_lifecycle") + || !swarm_online_runbook_row.contains("allAgents=true") + || !swarm_online_runbook_row.contains("receiptRequired=true") + || !swarm_online_runbook_row.contains("private=false") + { + anyhow::bail!( + "local Verse query smoke lost swarm-online-runbook daemon tool readback route" + ); + } let self_status = context .daemon_tool_capabilities .iter() @@ -1928,10 +2000,13 @@ fn run_cli() -> Result<()> { != Some("epiphany.cluster.self.private") || daemon_status_readback["eveSurfaceId"].as_str() != Some("eve://epiphany/self") || daemon_status_readback["availableToAllAgents"].as_bool() != Some(true) - || daemon_status_readback["hostedToolCount"].as_u64() != Some(3) + || daemon_status_readback["hostedToolCount"].as_u64() != Some(4) || !hosted_tool_ids .iter() .any(|id| id.as_str() == Some("epiphany.cluster.self.tool.service-health")) + || !hosted_tool_ids.iter().any(|id| { + id.as_str() == Some("epiphany.cluster.self.tool.swarm-online-runbook") + }) || daemon_status_private_state_exposed || daemon_status_readback["privateStateExposed"].as_bool() != Some(false) { @@ -2772,6 +2847,8 @@ 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 (swarm_online_runbook_readback, swarm_online_runbook_private_state_exposed) = + swarm_online_runbook_readback_from_idunn(&args)?; let service_health_action_rows = service_health_readback["serviceActionRows"] .as_array() .context("service-health readback lost service action rows")?; @@ -2782,7 +2859,7 @@ fn run_cli() -> Result<()> { .as_array() .context("service-health readback lost online preflight rows")?; let service_health_diagnostic = format!( - "status={:?}, mode={:?}, command={:?}, preflight={:?}, preflightCommand={:?}, childRunbooks={:?}, present={:?}, hashVerified={:?}, hashMismatch={:?}, missingArtifacts={:?}, attention={:?}, failed={:?}, missing={:?}, actions={}, preflightRows={}, privateHelper={}, privateJson={:?}", + "status={:?}, mode={:?}, command={:?}, preflight={:?}, preflightCommand={:?}, childRunbooks={:?}, present={:?}, hashVerified={:?}, hashMismatch={:?}, missingArtifacts={:?}, attention={:?}, failed={:?}, missing={:?}, actions={}, preflightRows={}, swarmOnline={:?}, swarmOnlinePrivate={}, privateHelper={}, privateJson={:?}", service_health_readback["status"].as_str(), service_health_readback["recommendedWrapperMode"].as_str(), service_health_readback["recommendedWrapperCommand"].as_str(), @@ -2798,6 +2875,8 @@ fn run_cli() -> Result<()> { service_health_readback["serviceExecutionMissingCheckCount"].as_u64(), service_health_action_rows.len(), service_health_preflight_rows.len(), + swarm_online_runbook_readback["status"].as_str(), + swarm_online_runbook_private_state_exposed, service_health_private_state_exposed, service_health_readback["privateStateExposed"].as_bool(), ); @@ -3064,6 +3143,25 @@ fn run_cli() -> Result<()> { || service_health_readback["onlinePreflightMissingCheckCount"].as_u64() != Some(10) || service_health_preflight_rows.len() != 2 + || swarm_online_runbook_readback["status"].as_str() + != Some("ready-for-elevated-operator") + || swarm_online_runbook_readback["wrapperMode"].as_str() + != Some("swarm-online-runbook") + || swarm_online_runbook_readback["wrapperCommand"].as_str() + != Some(WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND) + || swarm_online_runbook_readback["elevatedExecutionRequiresOperator"].as_bool() + != Some(true) + || swarm_online_runbook_readback["childRunbookCount"].as_u64() != Some(2) + || swarm_online_runbook_readback["childArtifactPresentCount"].as_u64() != Some(2) + || swarm_online_runbook_readback["childArtifactHashVerifiedCount"].as_u64() + != Some(2) + || swarm_online_runbook_readback["childArtifactMissingCount"].as_u64() != Some(0) + || swarm_online_runbook_readback["serviceExecutionFailedCheckCount"].as_u64() + != Some(11) + || swarm_online_runbook_readback["serviceExecutionMissingCheckCount"].as_u64() + != Some(10) + || swarm_online_runbook_readback["privateStateExposed"].as_bool() != Some(false) + || swarm_online_runbook_private_state_exposed || service_health_readback["serviceLifecycleAttentionCount"].as_u64() != Some(2) || service_health_readback["serviceExecutionFailedCheckCount"].as_u64() != Some(11) @@ -6365,6 +6463,12 @@ fn run_invoke_tool_command(args: &Args) -> Result<()> { } else { (serde_json::Value::Null, false) }; + let (swarm_online_runbook_readback, swarm_online_runbook_readback_private_state_exposed) = + if is_swarm_online_runbook_capability(capability) { + swarm_online_runbook_readback_from_idunn(args)? + } else { + (serde_json::Value::Null, false) + }; let (daemon_status_readback, daemon_status_readback_private_state_exposed) = if is_daemon_status_capability(capability) { let host_capabilities = tool_directory @@ -6402,6 +6506,7 @@ fn run_invoke_tool_command(args: &Args) -> Result<()> { }; let private_state_exposed = written_receipt.private_state_exposed || service_health_readback_private_state_exposed + || swarm_online_runbook_readback_private_state_exposed || daemon_status_readback_private_state_exposed || eve_connection_readback_private_state_exposed || authority_tool_readback_private_state_exposed; @@ -6427,9 +6532,7 @@ fn run_invoke_tool_command(args: &Args) -> Result<()> { requires_receipt: written_intent.requires_receipt, private_state_exposed, }); - println!( - "{}", - serde_json::to_string_pretty(&json!({ + let mut output = json!({ "status": "ok", "store": args.store, "runtimeId": args.runtime_id, @@ -6458,19 +6561,45 @@ fn run_invoke_tool_command(args: &Args) -> Result<()> { "requiresReceipt": written_intent.requires_receipt, "authorityGate": written_intent.authority_gate, "privateStateRequested": written_intent.private_state_requested, - "daemonStatusReadback": daemon_status_readback, - "daemonStatusReadbackPrivateStateExposed": daemon_status_readback_private_state_exposed, - "eveConnectionReadback": eve_connection_readback, - "eveConnectionReadbackPrivateStateExposed": eve_connection_readback_private_state_exposed, - "authorityToolReadback": authority_tool_readback, - "authorityToolReadbackPrivateStateExposed": authority_tool_readback_private_state_exposed, - "serviceHealthReadback": service_health_readback, - "serviceHealthReadbackPrivateStateExposed": service_health_readback_private_state_exposed, "privateStateExposed": private_state_exposed, - "invocationRows": [invocation_tui_row.clone()], - "tuiRows": [invocation_tui_row], - }))? + }); + let output_map = output + .as_object_mut() + .context("daemon tool invocation output must be a JSON object")?; + output_map.insert("daemonStatusReadback".to_string(), daemon_status_readback); + output_map.insert( + "daemonStatusReadbackPrivateStateExposed".to_string(), + json!(daemon_status_readback_private_state_exposed), ); + output_map.insert("eveConnectionReadback".to_string(), eve_connection_readback); + output_map.insert( + "eveConnectionReadbackPrivateStateExposed".to_string(), + json!(eve_connection_readback_private_state_exposed), + ); + output_map.insert("authorityToolReadback".to_string(), authority_tool_readback); + output_map.insert( + "authorityToolReadbackPrivateStateExposed".to_string(), + json!(authority_tool_readback_private_state_exposed), + ); + output_map.insert("serviceHealthReadback".to_string(), service_health_readback); + output_map.insert( + "serviceHealthReadbackPrivateStateExposed".to_string(), + json!(service_health_readback_private_state_exposed), + ); + output_map.insert( + "swarmOnlineRunbookReadback".to_string(), + swarm_online_runbook_readback, + ); + output_map.insert( + "swarmOnlineRunbookReadbackPrivateStateExposed".to_string(), + json!(swarm_online_runbook_readback_private_state_exposed), + ); + output_map.insert( + "invocationRows".to_string(), + json!([invocation_tui_row.clone()]), + ); + output_map.insert("tuiRows".to_string(), json!([invocation_tui_row])); + println!("{}", serde_json::to_string_pretty(&output)?); Ok(()) } @@ -6479,6 +6608,8 @@ fn default_daemon_tool_receipt_status( ) -> String { if is_service_health_capability(capability) { "accepted-for-service-lifecycle-readback".to_string() + } else if is_swarm_online_runbook_capability(capability) { + "accepted-for-swarm-online-runbook-readback".to_string() } else if is_daemon_status_capability(capability) { "accepted-for-daemon-status-readback".to_string() } else if is_eve_connect_capability(capability) { @@ -6743,12 +6874,39 @@ fn service_health_readback_from_idunn(args: &Args) -> Result<(serde_json::Value, )) } +fn swarm_online_runbook_readback_from_idunn(args: &Args) -> Result<(serde_json::Value, bool)> { + let (service_health, private_state_exposed) = service_health_readback_from_idunn(args)?; + Ok(( + json!({ + "status": service_health["onlinePreflightStatus"], + "lifecycleOwner": SERVICE_LIFECYCLE_OWNER, + "hostedBody": SERVICE_LIFECYCLE_HOSTED_BODY, + "wrapperMode": "swarm-online-runbook", + "wrapperCommand": WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND, + "elevatedExecutionRequiresOperator": true, + "elevatedExecutionCommandSource": "swarm-online-runbook artifact output", + "childRunbookCount": service_health["onlinePreflightChildRunbookCount"], + "childArtifactPresentCount": service_health["onlinePreflightPresentCount"], + "childArtifactHashVerifiedCount": service_health["onlinePreflightHashVerifiedCount"], + "childArtifactMismatchCount": service_health["onlinePreflightMismatchCount"], + "childArtifactMissingCount": service_health["onlinePreflightMissingArtifactCount"], + "serviceExecutionFailedCheckCount": service_health["onlinePreflightFailedCheckCount"], + "serviceExecutionMissingCheckCount": service_health["onlinePreflightMissingCheckCount"], + "childPreflightRows": service_health["onlinePreflightRows"], + "privateStateExposed": private_state_exposed, + }), + private_state_exposed, + )) +} + fn default_daemon_tool_result_ref( capability: &EpiphanyCultMeshDaemonToolCapabilityEntry, receipt_id: &str, ) -> String { if is_service_health_capability(capability) { "cultmesh://epiphany-local/daemon-service-lifecycle/receipt-directory".to_string() + } else if is_swarm_online_runbook_capability(capability) { + "cultmesh://epiphany-local/daemon-service-lifecycle/swarm-online-runbook".to_string() } else if is_daemon_status_capability(capability) { format!( "cultmesh://epiphany-local/daemon-status/{}", @@ -6778,6 +6936,11 @@ fn default_daemon_tool_result_summary( "{requesting_agent_id} requested service health; {} accepted typed routing to daemon service lifecycle readback via epiphany-verse-query receipt-directory or {}.", capability.host_daemon_id, WRAPPER_RECEIPT_DIRECTORY_COMMAND ) + } else if is_swarm_online_runbook_capability(capability) { + format!( + "{requesting_agent_id} requested Idunn swarm online runbook handoff; {} returned compact preflight/readback for {} without executing elevated service control.", + capability.host_daemon_id, WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND + ) } else if is_daemon_status_capability(capability) { format!( "{requesting_agent_id} requested daemon status; {} returned compact topology/liveness/tool readback through the daemon tool bus.", @@ -6808,6 +6971,15 @@ fn is_service_health_capability(capability: &EpiphanyCultMeshDaemonToolCapabilit && capability.receipt_contract_type == "epiphany.cultmesh.daemon_service_lifecycle_receipt" } +fn is_swarm_online_runbook_capability( + capability: &EpiphanyCultMeshDaemonToolCapabilityEntry, +) -> bool { + capability.capability_id == "epiphany.cluster.self.tool.swarm-online-runbook" + && capability.tool_name == "swarm-online-runbook" + && capability.operation == "prepareSwarmOnlineRunbook" + && capability.receipt_contract_type == "epiphany.cultmesh.daemon_service_lifecycle_receipt" +} + fn is_daemon_status_capability(capability: &EpiphanyCultMeshDaemonToolCapabilityEntry) -> bool { capability.tool_name == "status" && capability.operation == "readStatus" diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index 43a577b2..010668c0 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -5113,6 +5113,17 @@ pub fn epiphany_cultmesh_daemon_tool_capabilities() -> Vec= 16); + assert!(written.len() >= 18); let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?; let persona_status = node.get_required::( @@ -6724,6 +6735,10 @@ mod tests { let self_service_health = node.get_required::( "epiphany.cluster.self.tool.service-health", )?; + let self_swarm_online_runbook = node + .get_required::( + "epiphany.cluster.self.tool.swarm-online-runbook", + )?; let hands_action = node.get_required::( "epiphany.cluster.hands.tool.repo-action", )?; @@ -6734,6 +6749,7 @@ mod tests { for capability in [ persona_status.clone(), self_service_health.clone(), + self_swarm_online_runbook.clone(), hands_action.clone(), soul_verify.clone(), ] { @@ -6757,6 +6773,22 @@ mod tests { self_service_health.receipt_contract_type, EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE ); + assert_eq!( + self_swarm_online_runbook.authority_gate, + "daemon.service_lifecycle" + ); + assert_eq!( + self_swarm_online_runbook.operation, + "prepareSwarmOnlineRunbook" + ); + assert_eq!( + self_swarm_online_runbook.input_contract_type, + "epiphany.cultmesh.daemon_service_online_runbook_request" + ); + assert_eq!( + self_swarm_online_runbook.receipt_contract_type, + EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE + ); assert!( hands_action .notes @@ -7275,7 +7307,7 @@ mod tests { && advertisement.eve_surface_id == "eve://epiphany/persona" && !advertisement.private_state_exposed })); - assert!(context.daemon_tool_capabilities.len() >= 16); + assert!(context.daemon_tool_capabilities.len() >= 18); assert!(context.daemon_tool_capabilities.iter().all(|capability| { capability.available_to_all_agents && capability.requires_receipt diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 08aa8538..4270ec26 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -61,9 +61,9 @@ remembers doctrine; the branch remembers the blade. - `epiphany-verse-query receipt-directory` and `tools/epiphany_local_run.ps1 -Mode receipt-directory` are the compact latest-witness directory over local Verse. The command indexes typed projections for operator run, daemon poke, daemon tool invocation, Eve connection, Bifrost publication, Imagination consensus, coordinator run, Hands gate, role review, work-loop, cluster service lifecycle, single-service lifecycle, cluster service execution runbook, single-service execution runbook, scheduler, Persona speech, and agent-state SoA without exposing raw payloads or private worker context. It treats sealed service lifecycle failure states such as `not-elevated`, `execution-refused-not-elevated`, and `incomplete` as operator attention instead of private-state exposure, routes cluster lifecycle wounds to `cluster-service-execution-audit`, preserves `service-execution-audit` for single-service receipts, and exposes the runbook witnesses as separate display-only `cluster-service-execution-runbook` and `service-execution-runbook` rows. The lifecycle projection now reads the typed receipt family, splits `cluster-service-lifecycle` from `service-lifecycle`, selects the latest attention receipt before falling back to latest overall, and renders service lifecycle routes as `service-id::action` so compact rows name the owning lifecycle action without exposing raw audit payloads. Compact TUI rows append `followUp=`, artifact status, and SHA-256; wrapper proof `local-20260618-205920-451-383b0da7` printed all seventeen rows in `receiptRows`, including missing Hands/role/work-loop gates, Bifrost/Imagination witnesses, scheduler follow-up, runbook hashes, and service lifecycle attention. `missingRowCount` remains as a compatibility alias for absent witnesses, not a fault signal. Attention routing is now Rust-owned too: JSON includes `attentionRouteRows` derived from the same predicate as `attentionRowCount`, and the wrapper prints that field instead of matching arbitrary status strings. Live proof `local-20260618-212134-758-c7c56240` showed the stale degraded Hands daemon-poke receipt remains an `OK` historical row while `attentionRoutes` names only the active cluster/single-service lifecycle wounds. Daemon-poke rows now also resolve historical receipt status against current daemon liveness: source smoke proves degraded remains degraded before heartbeat recovery and becomes `resolved` after ready status returns, and live wrapper proof `local-20260618-212649-563-48647018` printed the old Hands poke receipt as `OK | Self | daemon-poke | resolved`. - Public doctrine source `https://gamecult.org/Blog/purge-the-heretek-from-our-daemonic-swarm` sharpens the current swarm audit: Odin sees but must not own, Gjallar is Odin's herald for whole-Verse sight, Idunn-like ledgers must advance instead of freezing old wounds, and Bifrost is the ledger gate for cross-repo purification receipts rather than transcript archaeology. - `tools/epiphany_local_run.ps1` now stamps local run ids as `local-YYYYMMDD-HHMMSS-fff-` instead of second-resolution ids, so concurrent operator rites get separate artifact roots and run receipts. Verified: `collaboration-feedback` and `bifrost-publication` launched in parallel in the same second and completed as `local-20260618-064814-171-dc0b8dd9` and `local-20260618-064814-149-2946d675`. -- `epiphany-verse-query tool-directory` and `tools/epiphany_local_run.ps1 -Mode tool-directory` are the compact read-only daemon tool directory. The report reads the same local Verse capability records used by `invoke-tool`, annotates them with host daemon readiness, and returns TUI rows plus direct `invocationCommand` and wrapper `wrapperInvocationCommand=tools/epiphany_local_run.ps1 -Mode tool-invoke -ToolCapabilityId -ToolRequestingAgentId -ToolRequestingClusterId `. TUI rows expose the global-tool contract directly, e.g. `READY | Hands | repo-action | submitHandsActionIntent | epiphany.cluster.hands.tool.repo-action | eve://epiphany/hands | authority=hands | input=epiphany.hands.action_intent | receiptType=epiphany.hands.action_review | allAgents=true | receipt=true | private=false`. Verified: fresh proof store returned seventeen globally available, receipt-gated, private-state-sealed tools with no host attention; smoke source-proves the compact Hands, Self `service-health`, and status readback rows plus command hints; wrapper proof `local-20260618-233719-320-e38a5549` printed all seventeen rows in the one-line `toolRows` summary with authority gates and advertised input/receipt contract types, including status tools, Self `service-health`, Hands `repo-action`, and Soul `verify`, with `privateStateExposed=False`. +- `epiphany-verse-query tool-directory` and `tools/epiphany_local_run.ps1 -Mode tool-directory` are the compact read-only daemon tool directory. The report reads the same local Verse capability records used by `invoke-tool`, annotates them with host daemon readiness, and returns TUI rows plus direct `invocationCommand` and wrapper `wrapperInvocationCommand=tools/epiphany_local_run.ps1 -Mode tool-invoke -ToolCapabilityId -ToolRequestingAgentId -ToolRequestingClusterId `. TUI rows expose the global-tool contract directly, e.g. `READY | Hands | repo-action | submitHandsActionIntent | epiphany.cluster.hands.tool.repo-action | eve://epiphany/hands | authority=hands | input=epiphany.hands.action_intent | receiptType=epiphany.hands.action_review | allAgents=true | receipt=true | private=false`. Verified: fresh proof store returned eighteen globally available, receipt-gated, private-state-sealed tools with no host attention; smoke source-proves the compact Hands, Self `service-health`, Self `swarm-online-runbook`, and status readback rows plus command hints; wrapper proof `local-20260619-032243-566-545b148c` printed all eighteen rows in the one-line `toolRows` summary with authority gates and advertised input/receipt contract types, including status tools, Self `service-health`, Self `swarm-online-runbook`, Hands `repo-action`, and Soul `verify`, with `privateStateExposed=False`. - 2026-06-18: Tool-directory TUI rows now render the advertised capability `authorityGate` as `authority=`, matching the JSON surface and invocation receipt row. Source smoke guards the Hands `repo-action` row with `authority=hands`; live wrapper proof `local-20260618-223032-345-74d9bdb2` printed all sixteen tool rows with authority gates, including `authority=imagination.consensus_discovery` for Eve connection tools, `authority=hands` for Hands repo-action, `authority=soul` for Soul verify, and `authority=none` for read-only status. -- `epiphany-verse-query swarm-overview` and `tools/epiphany_local_run.ps1 -Mode swarm-overview` are the one-command compact global-agent sight rite; `epiphany-verse-query gjallar` and `tools/epiphany_local_run.ps1 -Mode gjallar` are the first named Gjallar herald aliases over the same sealed whole-Verse report. The report composes narrow cluster topology, liveness, Odin/Eve surface, daemon tool, restart-policy coverage, receipt-directory service-lifecycle attention, and the shared core service-execution audit report; returns seven agents/daemons, seven clusters, seven private Verse ids, seven Eve surfaces, one public Persona discussion surface, seventeen globally invokable receipt-gated tools, command hints for topology/liveness/surfaces/tools/receipts/poke/connect/invoke/Bifrost-ledger/service-policy-directory/service-execution-audit, sealed `toolHostAttentionRows`/TUI rows for blocked daemon-hosted capabilities, sealed `serviceLifecycleAttentionRows`/TUI rows copied from the receipt directory, explicit `serviceLifecycleRecommended*` fields for service-manager follow-up, ordered `swarmActionRows`/TUI rows with Idunn/Epiphany lifecycle ownership on daemon/service physiology rows, authority/effect/wrapper-command/mutation/elevation metadata plus sealed `operatorArtifactRef`, `operatorArtifactStatus`, `operatorArtifactSha256`, `operatorArtifactExecutionCommand`, `operatorAftercareCommand`, and `completionAuditWrapper*` pointers for operator-runbook rows, `serviceExecutionFailedCheckRows`/TUI rows naming the failed sealed execution checks, and `privateStateExposed=false`; and avoids full local Verse serialization. Compact action TUI rows and wrapper `actionQueue` now include `owner=Idunn`, `hostedBody=Epiphany`, `aftercare=`, and scoped `failedChecks`/`missingChecks` on both service-lifecycle readback rows and elevated authority rows, so Gjallar remains sight while Idunn remains daemon keeper. Live `epiphany-verse-query` defaults to `.epiphany-run\cultmesh\local-verse.ccmp`, matching the wrapper and daemon supervisor; bare `epiphany-verse-query smoke` uses disposable `.epiphany-smoke\verse-query-default\local-verse.ccmp` unless an explicit `--store` is provided. The previous Windows debug stack-overflow wound is cut by running the CLI body on a larger worker-thread stack; broad `epiphany-verse-query smoke` now returns `status=ok`. Verified focused proof: live Gjallar artifact `local-20260619-012440-577-3f18a143` returned `recommended=swarm-online-runbook`, `serviceRecommended=cluster-service-execution-audit`, and four action rows whose non-mutating service readback plus elevated cluster/single-service runbook rows all carried `owner=Idunn`, `hostedBody=Epiphany`, aftercare, artifact hashes where present, failed/missing check counts, and `privateStateExposed=False`. +- `epiphany-verse-query swarm-overview` and `tools/epiphany_local_run.ps1 -Mode swarm-overview` are the one-command compact global-agent sight rite; `epiphany-verse-query gjallar` and `tools/epiphany_local_run.ps1 -Mode gjallar` are the first named Gjallar herald aliases over the same sealed whole-Verse report. The report composes narrow cluster topology, liveness, Odin/Eve surface, daemon tool, restart-policy coverage, receipt-directory service-lifecycle attention, and the shared core service-execution audit report; returns seven agents/daemons, seven clusters, seven private Verse ids, seven Eve surfaces, one public Persona discussion surface, eighteen globally invokable receipt-gated tools, command hints for topology/liveness/surfaces/tools/receipts/poke/connect/invoke/Bifrost-ledger/service-policy-directory/service-execution-audit, sealed `toolHostAttentionRows`/TUI rows for blocked daemon-hosted capabilities, sealed `serviceLifecycleAttentionRows`/TUI rows copied from the receipt directory, explicit `serviceLifecycleRecommended*` fields for service-manager follow-up, ordered `swarmActionRows`/TUI rows with Idunn/Epiphany lifecycle ownership on daemon/service physiology rows, authority/effect/wrapper-command/mutation/elevation metadata plus sealed `operatorArtifactRef`, `operatorArtifactStatus`, `operatorArtifactSha256`, `operatorArtifactExecutionCommand`, `operatorAftercareCommand`, and `completionAuditWrapper*` pointers for operator-runbook rows, `serviceExecutionFailedCheckRows`/TUI rows naming the failed sealed execution checks, and `privateStateExposed=false`; and avoids full local Verse serialization. Compact action TUI rows and wrapper `actionQueue` now include `owner=Idunn`, `hostedBody=Epiphany`, `aftercare=`, and scoped `failedChecks`/`missingChecks` on both service-lifecycle readback rows and elevated authority rows, so Gjallar remains sight while Idunn remains daemon keeper. Live `epiphany-verse-query` defaults to `.epiphany-run\cultmesh\local-verse.ccmp`, matching the wrapper and daemon supervisor; bare `epiphany-verse-query smoke` uses disposable `.epiphany-smoke\verse-query-default\local-verse.ccmp` unless an explicit `--store` is provided. The previous Windows debug stack-overflow wound is cut by running the CLI body on a larger worker-thread stack; broad `epiphany-verse-query smoke` now returns `status=ok` and `daemonTools=18`. Verified focused proof: live Gjallar artifact `local-20260619-012440-577-3f18a143` returned `recommended=swarm-online-runbook`, `serviceRecommended=cluster-service-execution-audit`, and four action rows whose non-mutating service readback plus elevated cluster/single-service runbook rows all carried `owner=Idunn`, `hostedBody=Epiphany`, aftercare, artifact hashes where present, failed/missing check counts, and `privateStateExposed=False`. - 2026-06-19: Service lifecycle readback follow-ups are now derived from the typed receipt action instead of hardcoding audit as the only compact action-row wrapper. `cluster-windows-service-execution-readiness` routes to `cluster-service-execution-readiness`; install/start/stop/status/reconcile route to their receipt-producing wrappers; audit still routes to audit. Source smoke now includes a synthetic readiness receipt guard, and live Gjallar proof `local-20260619-005713-795-96fd5370` still shows the current latest audit receipts as audit rows while failed-check anatomy preserves readiness/install/start/stop follow-ups, `owner=Idunn`, `hostedBody=Epiphany`, and `privateStateExposed=False`. - `epiphany-verse-query swarm-triage` and `tools/epiphany_local_run.ps1 -Mode swarm-triage` are the compact "see the swarm, then poke only if liveness attention exists" rite. It reads the compact overview first, writes no poke receipt when liveness is ready, routes non-ready daemons through the existing brake-aware `poke-down-daemons` receipt writer, carries overview's sealed service lifecycle attention rows, failed service-execution check rows, explicit service lifecycle recommendation, and ordered/effect-classified action queue with sealed runbook artifact and audit pointers without treating service-manager wounds as daemon-poke authority, and carries sealed `toolHostAttentionRows`/TUI rows so agents can see which advertised tools are blocked by a sick host daemon. Current overview routing means liveness-ready service execution attention recommends `swarm-online-runbook` globally while preserving `serviceRecommended=cluster-service-execution-audit` for readback. Live triage artifact `local-20260619-004523-003-a44ad06d` proved the no-poke path still prints Idunn/Epiphany ownership on service readback and elevated service-control action rows while `poked=0`. The older degraded Hands proof still routes through the topology-aware poke path and exposes blocked Hands tool-host rows plus liveness/tool-host action rows; source smoke `verse-query-completion-audit-row-smoke` proves the degraded single-poke triage path without a post-receipt full-context readback. - `swarmActionTuiRows` now carry the same audit and artifact-provenance visibility as JSON rows. Fresh source smoke `verse-query-action-tui-audit-smoke` and live artifact `local-20260618-164403-238-dba797ce` prove the compact rows include `artifact=present | sha256=3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0 | audit=cluster-service-execution-audit` on the `service-execution-authority` row and `artifact=none | sha256=none | audit=none` on the readback row, while service mutation still requires explicit elevated operator authority and private state remains sealed. @@ -79,7 +79,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-18: Direct status/reconcile/readiness summaries now print the next wrapper route beside the sealed receipt. `service-status` proof `local-20260618-231732-162-b1abd238` points missing supervisor-service status to `service-reconcile` plus `service-execution-audit`; `service-reconcile` proof `local-20260618-231754-575-25cc8a48` points the missing service to `service-install-plan` plus `service-execution-audit`; `service-execution-readiness` proof `local-20260618-231825-381-8d28f3a9` points `not-elevated` to `service-execution-runbook` plus `service-execution-audit`; and `cluster-service-execution-readiness` proof `local-20260618-231849-435-65651fe1` points the seven-service `not-elevated` cluster wound to `cluster-service-execution-runbook` plus `cluster-service-execution-audit`. - 2026-06-18: Direct launch runbook and cluster-audit summaries now share the same artifact/follow-up ergonomics as execution runbooks. `service-runbook` proof `local-20260618-232133-314-4e55120e` printed hash `85a956f768e584a9d098f13a9bf03fc3560915821a2ae7eaab94889dd9ecda85`, `followUp=tools/epiphany_local_run.ps1 -Mode service-launch`, and `aftercare=tools/epiphany_local_run.ps1 -Mode service-status`; `cluster-service-runbook` proof `local-20260618-232146-541-982dd60b` printed hash `40616423a9210101486949d07291bf795175579a39e99de5e5a759f8e0d7a78c`, `followUp=tools/epiphany_local_run.ps1 -Mode service-tick`, and `aftercare=tools/epiphany_local_run.ps1 -Mode swarm-overview`; `cluster-service-audit` proof `local-20260618-232200-992-b842ae01` printed seven missing services with `followUp=tools/epiphany_local_run.ps1 -Mode cluster-service-install-plan` plus `aftercare=tools/epiphany_local_run.ps1 -Mode cluster-service-execution-audit`. - 2026-06-18: Wrapper `service-plan` and `service-launch` now expose the native daemon-supervisor service lifecycle surfaces that handoff state already named. `service-plan` proof `local-20260618-232839-812-8dfa0c9e` printed the planned `epiphany-daemon-supervisor serve` command with `--max-iterations 1`, `followUp=service-runbook`, and `aftercare=service-status`. The first bounded `service-launch` proof exposed parent/child JSON contamination; `epiphany-daemon-supervisor service-launch` now silences child stdout/stderr so the parent lifecycle receipt owns stdout. Clean bounded proof `local-20260618-232935-349-7e3901c8` completed with `exitCode=0`, `followUp=service-status`, `aftercare=service-tick`, and `privateStateExposed=false`; follow-up runbook proof `local-20260618-233008-988-51fd6a36` confirmed `followUp=tools/epiphany_local_run.ps1 -Mode service-launch` is now a valid wrapper route. -- 2026-06-18: The daemon tool directory now advertises Self `service-health` as a globally available, receipt-gated, private-state-sealed CultMesh capability over the daemon service lifecycle contract. Source smoke reports `daemonTools=17`, and live wrapper proof `local-20260618-233719-320-e38a5549` printed `READY | Self | service-health | readServiceLifecycleStatus | epiphany.cluster.self.tool.service-health | eve://epiphany/self | authority=daemon.service_lifecycle | input=epiphany.cultmesh.daemon_service_lifecycle_query | receiptType=epiphany.cultmesh.daemon_service_lifecycle_receipt | allAgents=true | receipt=true | private=false`. +- 2026-06-19: The daemon tool directory now advertises Self `swarm-online-runbook` beside Self `service-health` as globally available, receipt-gated, private-state-sealed CultMesh capabilities over the daemon service lifecycle contract. Source smoke reports `daemonTools=18`, and live wrapper proof `local-20260619-032243-566-545b148c` printed `READY | Self | swarm-online-runbook | prepareSwarmOnlineRunbook | epiphany.cluster.self.tool.swarm-online-runbook | eve://epiphany/self | authority=daemon.service_lifecycle | input=epiphany.cultmesh.daemon_service_online_runbook_request | receiptType=epiphany.cultmesh.daemon_service_lifecycle_receipt | allAgents=true | receipt=true | private=false`. - 2026-06-18: Direct install plan/execute summaries now print install artifact hashes and receipt-producing follow-up wrappers. Cluster install plan proof `local-20260618-230937-335-71c4fdaa` and non-elevated execute proof `local-20260618-230937-313-cb288388` printed `artifactSha256=c6b697e173eb319073da341fc90c2963bcd6bee63d804349205b6309c88df764` plus `followUp=tools/epiphany_local_run.ps1 -Mode cluster-service-install-execute`; supervisor-service plan proof `local-20260618-230937-331-2e34b579` and non-elevated execute proof `local-20260618-231007-138-1dacc61b` printed `artifactSha256=7760943f618d13425f034226e0c5913f971d05f395b3abc12ae386acd2aaf56f` plus `followUp=tools/epiphany_local_run.ps1 -Mode service-install-execute`. - 2026-06-19: The `swarm-overview`/`swarm-triage`/`gjallar` action queue now carries scoped sealed service-execution wound counts on non-mutating service-lifecycle readback rows as well as elevated service-control rows, with compact wrapper/TUI rows rendering `failedChecks=` and `missingChecks=`. Live Gjallar proof `local-20260619-012440-577-3f18a143` printed priority 40 `cluster-service-execution-audit` with `failedChecks=5` and priority 41 `service-execution-audit` with `failedChecks=6`, while both rows stayed non-mutating, non-elevated, Idunn-owned, and `privateStateExposed=false`. - 2026-06-18: The elevated service-control action queue now emits one `service-execution-authority` row per sealed runbook witness instead of attaching all failed checks to the recommended cluster artifact. Source smoke seeds both cluster and single-service runbook witnesses and proves separate scoped rows. Live overview proof `local-20260618-221339-826-b1981064` and triage proof `local-20260618-221340-099-4b4baba8` printed priority 50 for `cluster-service-execution-runbook` with `failedChecks=5`, `missingChecks=0`, SHA-256 `3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0`, and aftercare `cluster-service-execution-audit`; and priority 51 for `service-execution-runbook` with `failedChecks=6`, `missingChecks=6`, SHA-256 `b213a3c11a8f11a03061fcd743f507edaa59bc6767257b79cef63329596375e7`, and aftercare `service-execution-audit`, with no private state exposure. @@ -116,7 +116,7 @@ remembers doctrine; the branch remembers the blade. - `bifrost-publication` is the compact non-mutating Bifrost publication proof; use it to prove body-change routing, credit, and GitHub publication receipt state without performing GitHub mutation. Its JSON now points back to compact swarm overview and tool-directory readback. - `bifrost-ledger` is the compact Bifrost/Imagination readback rite; use it after collaboration or publication writes to see the latest body-change, GitHub, feedback, and consensus receipts without opening the full local Verse. - `tool-directory` is the non-mutating daemon tool sight rite; it shows which globally available daemon-hosted tools any agent can invoke through typed intents and receipts, while still exposing host readiness. -- `tool-invoke` now embeds compact readbacks for common daemon-hosted tools. Status calls return `daemonStatusReadback`, Eve calls return `eveConnectionReadback`, Self `service-health` returns Idunn-owned `serviceHealthReadback`, and Hands/Soul authority tools return `authorityToolReadback` with gate, input contract, receipt contract, intent/receipt routes, host cluster, and private-state seal. This proves global tool ergonomics without moving action, verification, or daemon lifecycle ownership into the wrapper; live proofs routed Persona to Hands `repo-action` (`local-20260619-021628-143-7bf7f2e0`) and Soul `verify` (`local-20260619-021701-458-852cfa6f`) with `privateStateExposed=false`. +- `tool-invoke` now embeds compact readbacks for common daemon-hosted tools. Status calls return `daemonStatusReadback`, Eve calls return `eveConnectionReadback`, Self `service-health` returns Idunn-owned `serviceHealthReadback`, Self `swarm-online-runbook` returns Idunn-owned `swarmOnlineRunbookReadback`, and Hands/Soul authority tools return `authorityToolReadback` with gate, input contract, receipt contract, intent/receipt routes, host cluster, and private-state seal. This proves global tool ergonomics without moving action, verification, or daemon lifecycle ownership into the wrapper; live proofs routed Persona to Hands `repo-action` (`local-20260619-021628-143-7bf7f2e0`), Soul `verify` (`local-20260619-021701-458-852cfa6f`), and Self `swarm-online-runbook` (`local-20260619-032244-273-acb3c6a4`) with `privateStateExposed=false`. - `gjallar` is the non-mutating whole-Verse herald to run first when reorienting; `swarm-overview` remains its compatibility name. It locates agents, cluster/private-Verse topology, daemon liveness, Eve surfaces, and daemon tools in one compact report without opening private Verse state or full-context debug serialization. - Idunn, not Codex/Self/Gjallar, owns daemon survival and service lifecycle physiology. `tools/epiphany_local_run.ps1 -Mode swarm-online-runbook` now generates an Idunn-owned service lifecycle runbook for the Epiphany hosted body: the artifact verifies each sealed child runbook artifact exists and matches its advertised SHA-256 before launching it with `Start-Process ... -PassThru`, records child exit codes, continues after child failure, runs aftercare audits through `tools\epiphany_local_run.ps1` with explicit arguments instead of string evaluation, and exits nonzero if any child or aftercare step fails. Its wrapper JSON and one-line summary print the exact swarm-level `elevatedCommand=Start-Process PowerShell -Verb RunAs -Wait ...`, parent artifact SHA-256, `verifiesChildArtifactSha256=True`, `usesExplicitAftercareArguments=True`, child/aftercare row counts, aftercare commands, owner, hosted body, and private-state seal; JSON now includes structured `childRunbookRows` and `aftercareRows` with service ids, routes, SHA-256s, audit modes, authority gates, failed-check counts, and private-state seals. Proof `local-20260619-013021-159-c93088be` generated and inspected that guard without mutating services. It still requires explicit elevated operator authority before service mutation. - Service execution audits now expose the exact Idunn runbook route at the audit mouth: `cluster-service-execution-audit` and `service-execution-audit` JSON and wrapper summaries include the sealed runbook path, SHA-256, elevated `Start-Process PowerShell -Verb RunAs -Wait ...` command, aftercare command, and `requiresElevatedAuthority=True`. Daemon-supervisor `*smoke` commands default to `.epiphany-smoke/daemon-supervisor-/local-verse.ccmp` unless `--store` is explicit, keeping synthetic smoke receipts out of the shared live local Verse. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 6106080b9d93f22eab35fc16e64eee547c40c1d3..a83e298f21f86cc2dbdc6d005936f4b5b5be17cf 100644 GIT binary patch delta 308 zcmeBd7uwk^v_XQA+sNF?&@k#4153-a&B~00jEo2Ei#i zjSP&;bPddO4J|_qjI4|%Kl~}p%*5m}eXlo**7Q%IEFvt4#R`ej6}ebMSUpop^YW%o zoWm?^o{^ZBlAo5Qrx2W9T9llsP@J2eovKijT998gW=wP?TSeq+d5PuPi@%df{JYQBkNVCb~xE#=42gNyf=$i6+z6H?gR)DwJoIWK8#O oWRaf!p@}6*EWaSND6u5JC@8hCG_xo*#WtjVQGBE-%h-ThCm5Jp`0|0}F B58D6$ diff --git a/state/map.yaml b/state/map.yaml index 5778a49d..82e6f9da 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -618,14 +618,14 @@ current_status: - `epiphany-verse-query restart-policy-directory` and `tools/epiphany_local_run.ps1 -Mode service-policy-directory` provide the compact scheduler coverage sight organ. It reads daemon topology/status plus durable `epiphany.cultmesh.daemon_restart_policy.v0` rows through a narrow CultMesh restart-policy directory loader, reports each daemon as `ENABLED`, `DISABLED`, or `MISSING`, treats disabled and missing policies as recovery attention, returns covered/enabled/disabled/missing/attention counts, and publishes explicit policy-write plus scheduler-tick follow-up commands without creating or mutating policies. Compact TUI rows now expose `owner=Idunn`, `hostedBody=Epiphany`, cooldown, reconcile interval, heartbeat stale threshold, failure count, last result, `followUp=`, and `private=false`; wrapper proof `local-20260619-003720-135-799146f3` prints the Rust-owned `tuiRows` directly for all seven faculties as `ENABLED` with `owner=Idunn`, `hostedBody=Epiphany`, `last=ready`, `cooldown=30s`, `reconcile=60s`, `stale=300s`, `followUp=tools/epiphany_local_run.ps1 -Mode service-tick`, and `private=false`, instead of rebuilding policy text in PowerShell. Direct and wrapper proof now report seven daemons, seven covered policies, seven enabled policies, zero disabled, zero missing, zero attention, `status=ok`, `lifecycleOwner=Idunn`, `hostedBody=Epiphany`, and `privateStateExposed=false`. This is a real Idunn-owned daemon heartbeat body with non-mutating per-organ launch and install artifacts, but not yet executed installed per-organ OS services. - `https://gamecult.org/Blog/purge-the-heretek-from-our-daemonic-swarm` is a public doctrine receipt for the Perfect Machine audit pressure: organs must not borrow each other's crowns, witnesses need owning mouths, surfaces reflect rather than rule, and cross-repo purification needs Bifrost-shaped ledger evidence instead of relying on recoverable transcripts or commit trails alone. - `tools/epiphany_local_run.ps1` now uses collision-resistant local run ids (`local-YYYYMMDD-HHMMSS-fff-`) for artifact roots and operator run receipts. Same-second parallel compact wrapper proofs for `collaboration-feedback` and `bifrost-publication` produce separate artifact drawers and both complete, so operator rites no longer collide on second-resolution run ids. - - `epiphany-verse-query tool-directory` and `tools/epiphany_local_run.ps1 -Mode tool-directory` provide the compact daemon tool sight organ over the same local Verse capability records used by `invoke-tool`. It returns seventeen globally available daemon-hosted capabilities, host readiness counts, direct `invocationCommand`, wrapper `wrapperInvocationCommand=tools/epiphany_local_run.ps1 -Mode tool-invoke -ToolCapabilityId -ToolRequestingAgentId -ToolRequestingClusterId `, and the invariants `availableToAllAgents=true`, `requiresReceipt=true`, `privateStateExposed=false`. Agent-friendly TUI rows now carry the same contract bits, authority gate, and advertised payload/review contract types, e.g. `READY | Hands | repo-action | submitHandsActionIntent | epiphany.cluster.hands.tool.repo-action | eve://epiphany/hands | authority=hands | input=epiphany.hands.action_intent | receiptType=epiphany.hands.action_review | allAgents=true | receipt=true | private=false`; wrapper proof `local-20260618-233719-320-e38a5549` prints all seventeen rows in the one-line `toolRows` summary, including Self `service-health` as `readServiceLifecycleStatus` with `authority=daemon.service_lifecycle`, `input=epiphany.cultmesh.daemon_service_lifecycle_query`, and `receiptType=epiphany.cultmesh.daemon_service_lifecycle_receipt`, plus Eve connection tools, Hands `repo-action`, and Soul `verify`. `invoke-tool` runs through a smaller extracted command handler and emits compact invocation rows with requester/host display names, requesting/host private Verses and Eve surfaces, host daemon id, tool operation, capability id, intent id, receipt id/status, authority gate, `allAgents=true`, `receiptRequired=true`, and `private=false`; status invocation embeds `daemonStatusReadback` with compact topology/liveness/tool-count fields, Eve connection invocation embeds `eveConnectionReadback` with compact CultMesh surface routing and collaboration commands, and service-health invocation embeds `serviceHealthReadback` with Idunn lifecycle attention/action/failed-check rows plus swarm-online preflight proof (`ready-for-elevated-operator`, two present child runbooks, two verified hashes), so agents get useful readback through the advertised daemon tool without opening full local Verse state or taking over Idunn's daemon-keeper role. + - `epiphany-verse-query tool-directory` and `tools/epiphany_local_run.ps1 -Mode tool-directory` provide the compact daemon tool sight organ over the same local Verse capability records used by `invoke-tool`. It returns eighteen globally available daemon-hosted capabilities, host readiness counts, direct `invocationCommand`, wrapper `wrapperInvocationCommand=tools/epiphany_local_run.ps1 -Mode tool-invoke -ToolCapabilityId -ToolRequestingAgentId -ToolRequestingClusterId `, and the invariants `availableToAllAgents=true`, `requiresReceipt=true`, `privateStateExposed=false`. Agent-friendly TUI rows now carry the same contract bits, authority gate, and advertised payload/review contract types, e.g. `READY | Hands | repo-action | submitHandsActionIntent | epiphany.cluster.hands.tool.repo-action | eve://epiphany/hands | authority=hands | input=epiphany.hands.action_intent | receiptType=epiphany.hands.action_review | allAgents=true | receipt=true | private=false`; wrapper proof `local-20260619-032243-566-545b148c` prints all eighteen rows in the one-line `toolRows` summary, including Self `service-health` as `readServiceLifecycleStatus` and Self `swarm-online-runbook` as `prepareSwarmOnlineRunbook`, both under `authority=daemon.service_lifecycle` with private-state-sealed lifecycle receipt contracts, plus Eve connection tools, Hands `repo-action`, and Soul `verify`. `invoke-tool` runs through a smaller extracted command handler and emits compact invocation rows with requester/host display names, requesting/host private Verses and Eve surfaces, host daemon id, tool operation, capability id, intent id, receipt id/status, authority gate, `allAgents=true`, `receiptRequired=true`, and `private=false`; status invocation embeds `daemonStatusReadback` with compact topology/liveness/tool-count fields, Eve connection invocation embeds `eveConnectionReadback` with compact CultMesh surface routing and collaboration commands, service-health invocation embeds `serviceHealthReadback` with Idunn lifecycle attention/action/failed-check rows plus swarm-online preflight proof, and swarm-online-runbook invocation embeds `swarmOnlineRunbookReadback` with `ready-for-elevated-operator`, two present child runbooks, two verified hashes, zero missing artifacts, eleven failed checks, zero missing checks, and `operatorRequired=True`. This makes the Idunn handoff globally discoverable without opening full local Verse state or taking over Idunn's daemon-keeper role; live invocation proof `local-20260619-032244-273-acb3c6a4` returned `privateStateExposed=False`. - `epiphany-verse-query cluster-topology` and `tools/epiphany_local_run.ps1 -Mode cluster-topology` provide the compact cluster/body/private-Verse/daemon sight organ over local Verse topology rows through a narrow CultMesh loader. The report returns seven clusters, seven private Verse ids, seven daemon ids, one public Persona discussion cluster, agent-friendly TUI rows such as `PUBLIC | Persona | cluster=epiphany.cluster.persona | role=Persona | privateVerse=epiphany.cluster.persona.private | body=repo:E:/Projects/EpiphanyAgent | bodyKind=repository | daemon=epiphany-daemon-persona | surface=eve://epiphany/persona`, and `privateStateExposed=false`; `epiphany-verse-query smoke` source-proves the compact topology invariants, and wrapper proof `local-20260618-225347-337-cea74491` prints all seven standing-faculty rows in the one-line `topologyRows` summary. - `epiphany-verse-query swarm-overview` and `tools/epiphany_local_run.ps1 -Mode swarm-overview` provide the one-command compact global-agent sight rite. It composes narrow cluster topology, liveness, Odin/Eve surface, daemon tool, restart-policy coverage, receipt-directory service-lifecycle attention, and the shared core service-execution audit report without full local Verse serialization, returning seven agents/daemons, seven clusters, seven private Verse ids, seven Eve surfaces, one public Persona discussion surface, sixteen globally invokable receipt-gated tools, command hints for topology/liveness/surfaces/tools/receipts/poke/connect/invoke/Bifrost-ledger/restart-policy coverage, wrapper command hints for overview/swarm-online-runbook/receipts/poke/connect/tool-invoke/Bifrost-ledger/service-policy-directory/service-execution-audit, sealed `toolHostAttentionRows`/TUI rows for blocked daemon-hosted capabilities, sealed `serviceLifecycleAttentionRows`/TUI rows copied from the receipt directory, `serviceExecutionFailedCheckRows`/TUI rows naming failed sealed execution checks, explicit `serviceLifecycleRecommended*` fields so service-manager follow-up remains visible even when global `recommendedWrapperMode` is occupied by liveness or policy, and ordered `swarmActionRows`/TUI rows with authority gates, effect class, wrapper command, mutation flag, elevation flag, sealed `operatorArtifactRef`, `operatorArtifactStatus`, `operatorArtifactSha256`, `operatorArtifactExecutionCommand`, `operatorAftercareCommand`, and `completionAuditWrapper*` for operator-runbook rows. Compact action TUI rows now also render `aftercare=`, so the Rust-owned row itself names the post-run audit command instead of relying on wrapper compatibility summaries. Current live overview `local-20260619-001128-955-195f4e65` returns `status=attention`, `livenessStatus=ready`, `recoveryStatus=attention`, `recommendedWrapperMode=swarm-online-runbook`, `recommendedWrapperCommand=tools/epiphany_local_run.ps1 -Mode swarm-online-runbook`, `serviceLifecycleRecommendedWrapperMode=cluster-service-execution-audit`, `toolHostAttentionCount=0`, `serviceLifecycleAttentionCount=2`, `swarmActionCount=4`, non-mutating service lifecycle readback rows with `aftercare=none`, and elevated service authority rows with `aftercare=tools/epiphany_local_run.ps1 -Mode cluster-service-execution-audit` / `aftercare=tools/epiphany_local_run.ps1 -Mode service-execution-audit`, present runbook artifacts, SHA-256 provenance, failed/missing check counts, and `privateStateExposed=false`. `tools/epiphany_local_run.ps1 -Mode swarm-online-runbook` now prints and stores the swarm-level elevated command for its generated Idunn-owned artifact, and the generated parent runbook verifies each child runbook artifact exists and matches its advertised SHA-256 before launching it elevated, then runs aftercare audits through the known wrapper `ScriptPath` plus explicit argument arrays instead of string evaluation. The operator sees the exact `Start-Process PowerShell -Verb RunAs -Wait ...` command, parent artifact hash, child hash guard, aftercare, owner, hosted body, and private-state seal before granting service mutation authority; the wrapper JSON also carries structured `childRunbookRows` and `aftercareRows` with service ids, routes, SHA-256s, audit modes, authority gates, failed-check counts, and private-state seals. Live proof `local-20260619-013021-159-c93088be` generated the parent artifact with two child rows, two aftercare rows, `usesExplicitAftercareArguments=true`, no `Invoke-Expression`, child hash guards, and wrapper-path aftercare calls. If a local runbook artifact is missing, source smoke proves the same row is demoted to `status=runbook-artifact-missing`, `wrapperMode=cluster-service-execution-runbook`, `effectClass=service-lifecycle-runbook-regeneration`, `operatorArtifactSha256=none`, `operatorArtifactExecutionCommand=none`, `operatorAftercareCommand=none`, `mutatesState=false`, and `requiresElevatedAuthority=false` instead of pretending elevated service authority is actionable. Degraded daemon overview still routes global recommendation to `swarm-poke-down` first while independent action rows preserve the liveness/tool-host duties; liveness action rows are explicitly mutating typed lifecycle pokes but do not require elevation, while service execution authority rows make the operator grant boundary visible. `epiphany-verse-query` defaults to the shared `.epiphany-run\cultmesh\local-verse.ccmp` store for live query/readback, while bare `epiphany-verse-query smoke` now uses a disposable `.epiphany-smoke\verse-query-default\local-verse.ccmp` fixture unless an explicit `--store` is provided. - `epiphany-verse-query swarm-triage` and `tools/epiphany_local_run.ps1 -Mode swarm-triage` compose the compact swarm overview with the existing brake-aware daemon poke receipt writer. Triage pokes only daemon liveness attention; service-manager lifecycle wounds are reflected from overview as sealed `serviceLifecycleAttentionRows`/TUI rows, `serviceExecutionFailedCheckRows`/TUI rows, explicit `serviceLifecycleRecommended*` fields, and ordered `swarmActionRows`, but do not cause daemon poke receipts, while blocked daemon-hosted tools ride as sealed `toolHostAttentionRows`/TUI rows so agents can see which advertised capabilities are unavailable because their host body is sick. Current live triage `local-20260618-150015-844-aba20563` returns `status=noop`, `overviewStatus=attention`, `livenessStatus=ready`, `recoveryStatus=attention`, `clusterCount=7`, `privateVerseCount=7`, `pokedDaemonCount=0`, `recommendedWrapperMode=cluster-service-execution-audit`, `serviceLifecycleRecommendedWrapperMode=cluster-service-execution-audit`, `swarmActionCount=2`, the same sealed service readback plus operator-elevated runbook rows, including `operatorArtifactStatus=present`, `operatorArtifactRef=E:\Projects\EpiphanyAgent\.epiphany-run\local-20260618-132257-139-26213a29\epiphany-cluster-daemon-services-execution-runbook.ps1`, and `completionAuditWrapperCommand=tools/epiphany_local_run.ps1 -Mode cluster-service-execution-audit` on the elevated row, empty daemon/tool-host attention arrays, `serviceLifecycleAttentionCount=2`, routes `epiphany-cluster-daemon-services::cluster-windows-service-execution-audit` and `epiphany-daemon-supervisor-service::windows-service-execution-audit`, direct and wrapper command hints including `wrapperInvokeTool` and `wrapperBifrostLedger=tools/epiphany_local_run.ps1 -Mode bifrost-ledger`, and `privateStateExposed=false`; degraded Hands proof returns `status=ok`, `overviewStatus=attention`, topology and daemon TUI rows, blocked Hands-hosted tool rows, one sealed topology-aware poke receipt for `epiphany-daemon-hands` with `bodyDomain=repo:E:/Projects/EpiphanyAgent`, `privateVerseId=epiphany.cluster.hands.private`, `eveSurfaceId=eve://epiphany/hands`, `observedStatus=degraded`, `attentionDaemonIds=[epiphany-daemon-hands]`, `attentionToolHostDaemonIds=[epiphany-daemon-hands]`, and liveness/tool-host action rows with no private-state exposure. Source smoke `verse-query-service-execution-failed-checks-clean` proves a physical synthetic written runbook plus incomplete service audit receipts expose both service lifecycle readback and failed-check anatomy with no Windows service mutation. - Compact `swarmActionTuiRows` now match the JSON service-execution queue including local runbook SHA-256 provenance: live artifact `local-20260618-164403-238-dba797ce` shows `050 | service-execution-authority | operator-authority-required | operator-elevated-runbook | operator.elevated_windows_service_control | mutates=true | elevated=true | artifact=present | sha256=3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0 | audit=cluster-service-execution-audit`, while the readback row stays `artifact=none | sha256=none | audit=none`. Source smoke `verse-query-action-tui-audit-smoke` guards this agent-friendly TUI surface. - Receipt directory rows now carry `artifactStatus` and `artifactSha256` beside `artifactRef`, using the same `none` / `external-ref` / `present` / `missing` vocabulary as action rows and hashing present local artifacts at the receipt-directory layer. Live wrapper artifact `local-20260618-165005-139-6188fe30` proves the cluster service execution runbook row reports `artifactStatus=present`, `artifactSha256=3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0`, and TUI `artifact=present | sha256=3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0`; the per-service execution runbook row reports `artifactSha256=b213a3c11a8f11a03061fcd743f507edaa59bc6767257b79cef63329596375e7`; non-artifact rows report `artifactSha256=none`. Wrapper proof `local-20260618-165319-478-e929d2bd` also prints compact `artifactHashes=cluster-service-execution-runbook:3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0; service-execution-runbook:b213a3c11a8f11a03061fcd743f507edaa59bc6767257b79cef63329596375e7` in the one-line receipt-directory summary. Source smoke guards present-artifact SHA-256 in receipt-directory JSON/TUI, action-row SHA-256, missing-artifact demotion, and failed-check anatomy. `epiphany-verse-query receipt-directory` also derives compact artifact counts (`artifactNoneCount`, `artifactExternalRefCount`, `artifactPresentCount`, `artifactMissingCount`) from rows instead of storing a second truth. Live readback reports `artifactNone=13`, `artifactExternalRef=2`, `artifactPresent=2`, `artifactMissing=0`, and `privateStateExposed=false`; a clean direct empty-store readback reported all 17 rows as `artifactNone`. The earlier all-in-one `epiphany-verse-query smoke` Windows stack overflow was fixed by cutting full `query_epiphany_local_verse_context` out of `load_swarm_overview_report`; overview now reads daemon service lifecycle rows through narrow history/latest loaders. - Wrapper `swarm-overview` and `swarm-triage` summaries now forward the Rust-owned compact TUI row families instead of rebuilding the global sight surface in PowerShell: `actionRows`, `daemonRows`, `toolRows` where present, `policyRows` where present, `toolAttentionRows`, `serviceAttentionRows`, and `serviceFailedCheckRows`. The older compatibility summaries still surface lifecycle receipt `artifactStatus`, local runbook `sha256`, operator aftercare command, and compact service execution failed-check anatomy. Live artifacts `local-20260618-210646-478-88b58f07` and `local-20260618-210646-474-2fb504ff` prove overview/triage print seven READY daemon rows, sixteen globally invokable receipt-gated tool rows, seven enabled restart-policy rows, two ordered service action rows, two service lifecycle attention rows, five sealed failed service-execution check rows, and `privateStateExposed=false`. The Rust-owned action queue now enumerates every sealed service-lifecycle attention receipt instead of only the selected global recommendation: live wrapper proof `local-20260618-214044-049-a63d008c` printed priority 40 `cluster-service-execution-audit` and priority 41 `service-execution-audit` non-mutating readback rows with `artifactStatus=external-ref`, `sha256=none`, service-manager artifact refs for cluster execution audit and single-service execution audit, and `privateStateExposed=false`, while leaving the elevated runbook authority rows unchanged. The failed-check anatomy now aggregates cluster and single-service execution audit reports too, carries service identity, and renders `followUp=` for each failed/missing check so the compact row names the receipt-producing or readback route without opening raw audit payloads. Live wrapper proof `local-20260618-224925-221-8e114063` printed cluster readiness/install/start/audit/stop failures with follow-ups such as `cluster-service-execution-readiness`, `cluster-service-install-execute`, and `cluster-service-execution-audit`, plus supervisor-service missing checks with follow-ups such as `service-execution-readiness`, `service-install-execute`, `service-status`, and `service-reconcile`, all sealed with `privateStateExposed=false`. The action queue now carries scoped service-execution wound counters on service-lifecycle readback rows as well as elevated authority rows, so a compact row that says `attention` also says why: live Gjallar proof `local-20260619-012440-577-3f18a143` printed priority 40 `cluster-service-execution-audit` with `failedChecks=5` and priority 41 `service-execution-audit` with `failedChecks=6`, while both rows stayed non-mutating, non-elevated, Idunn-owned, and `privateStateExposed=false`. Source smoke seeds both cluster and single-service runbook witnesses and proves distinct authority rows. Live overview/triage proofs `local-20260618-221339-826-b1981064` and `local-20260618-221340-099-4b4baba8` printed priority 50 `cluster-service-execution-runbook` with `failedChecks=5`, `missingChecks=0`, SHA-256 `3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0`, and aftercare `cluster-service-execution-audit`, plus priority 51 `service-execution-runbook` with `failedChecks=6`, `missingChecks=6`, SHA-256 `b213a3c11a8f11a03061fcd743f507edaa59bc6767257b79cef63329596375e7`, and aftercare `service-execution-audit`, with `privateStateExposed=false`. `SwarmActionRow` now exposes explicit `serviceId` and `serviceRoute` fields so agents can identify the body/action without parsing artifact paths or prose; Rust TUI and wrapper action queues render `service=` and `route=` for service lifecycle and service authority rows, while non-service rows render `none`. Source smoke guards both fields, and live overview/triage proofs `local-20260618-221912-231-805389bf` and `local-20260618-221912-282-a79ba8bd` showed the cluster and supervisor-service identities on readback and elevated runbook rows with `privateStateExposed=false`. `ReceiptDirectoryRow` now owns the same explicit `serviceId`/`serviceRoute` fields, so action rows consume typed service identity from the receipt-directory organ instead of parsing `route`; non-service receipt families carry `none`, while service lifecycle/runbook rows carry the typed body and route. Source smoke guards the fields, and live receipt-directory proof `local-20260618-222641-218-60106c79` printed `service=epiphany-cluster-daemon-services` and `service=epiphany-daemon-supervisor-service` on service attention/readiness rows and runbook witnesses with no private-state exposure. - - `SwarmActionRow` now carries `lifecycleOwner` and `hostedBody` so Gjallar/overview/triage action queues distinguish sight from daemon-keeper authority. Daemon liveness, restart-policy, service-lifecycle readback, and elevated service-control rows carry `Idunn` / `Epiphany`; non-lifecycle rows carry `none`. Rust TUI rows plus wrapper `actionQueue` render `owner=Idunn` and `hostedBody=Epiphany` for service readback and elevated service-control rows. Focused live proofs `local-20260619-004523-347-620b40e9` (`gjallar`) and `local-20260619-004523-003-a44ad06d` (`swarm-triage`) show the ownership fields on all service action rows with no daemon poke when liveness is ready and no private-state exposure. The broad `epiphany-verse-query smoke` Windows debug stack-overflow wound is now cut by running the CLI body on a larger worker-thread stack; direct smoke returns `status=ok` with seven clusters, seven daemon statuses, seventeen daemon tools, and the sealed latest receipt ids. + - `SwarmActionRow` now carries `lifecycleOwner` and `hostedBody` so Gjallar/overview/triage action queues distinguish sight from daemon-keeper authority. Daemon liveness, restart-policy, service-lifecycle readback, and elevated service-control rows carry `Idunn` / `Epiphany`; non-lifecycle rows carry `none`. Rust TUI rows plus wrapper `actionQueue` render `owner=Idunn` and `hostedBody=Epiphany` for service readback and elevated service-control rows. Focused live proofs `local-20260619-004523-347-620b40e9` (`gjallar`) and `local-20260619-004523-003-a44ad06d` (`swarm-triage`) show the ownership fields on all service action rows with no daemon poke when liveness is ready and no private-state exposure. The broad `epiphany-verse-query smoke` Windows debug stack-overflow wound is now cut by running the CLI body on a larger worker-thread stack; direct smoke returns `status=ok` with seven clusters, seven daemon statuses, eighteen daemon tools, and the sealed latest receipt ids. - Direct wrapper audit summaries now expose the same follow-up ergonomics as the global sight rows. `tools/epiphany_local_run.ps1 -Mode cluster-service-execution-audit` and `-Mode service-execution-audit` print `failed check rows` with `serviceId::action=status`, artifact ref, local artifact SHA-256 when present, and `followUp=` for each failed/missing check. Live proofs `local-20260618-225923-468-d818951a` and `local-20260618-225923-529-7cfa2bb3` showed cluster readiness/install/start/audit/stop failures and supervisor-service readiness/install/start/status/reconcile/stop missing checks with actionable follow-up wrappers and `privateStateExposed=false`. - Service execution audits now carry their own elevated runbook readback instead of relying on Gjallar or wrapper memory. `epiphany-daemon-supervisor windows-service-execution-audit` and `cluster-windows-service-execution-audit` return `runbookPath`, `runbookSha256`, `elevatedCommand`, `requiresElevatedAuthority`, `aftercareMode`, and `aftercareCommand` from the sealed runbook witness; the wrapper summaries print those fields directly for `service-execution-audit` and `cluster-service-execution-audit`. Live proofs `local-20260619-024011-505-a18982fa` and `local-20260619-024010-980-842fc3a6` showed incomplete audits with repaired runbook hashes, exact `Start-Process PowerShell -Verb RunAs -Wait ... -File ` commands, explicit aftercare, and no private-state exposure. `epiphany-daemon-supervisor` smoke commands now default to `.epiphany-smoke/daemon-supervisor-/local-verse.ccmp` unless `--store` is explicit, so synthetic smoke receipts cannot become the latest live local Verse service proof by accident. - Gjallar/swarm-overview service-execution authority rows now treat synthetic `smoke://` runbook witnesses as missing artifacts, not external executable refs. Such rows demote to `runbook-artifact-missing`, `service-lifecycle-runbook-regeneration`, no elevated authority, no mutation, no execution command, and no aftercare until a real local runbook artifact is regenerated. Source smoke guards this demotion, while live local Verse was repaired by regenerating the cluster execution runbook and re-auditing it: Gjallar proof `local-20260619-025100-231-0d70bace` showed both cluster and single-service authority rows with `artifactStatus=present`, real SHA-256s, exact elevated commands, aftercare audits, Idunn/Epiphany ownership, and no `smoke://` artifact refs. diff --git a/tools/epiphany_local_run.ps1 b/tools/epiphany_local_run.ps1 index 4a4a93d7..d5b5f164 100644 --- a/tools/epiphany_local_run.ps1 +++ b/tools/epiphany_local_run.ps1 @@ -2128,6 +2128,10 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) { if ($null -ne $result.serviceHealthReadback -and $null -ne $result.serviceHealthReadback.status) { $serviceHealth = "status=$($result.serviceHealthReadback.status):preflight=$($result.serviceHealthReadback.onlinePreflightStatus):childRunbooks=$($result.serviceHealthReadback.onlinePreflightChildRunbookCount):present=$($result.serviceHealthReadback.onlinePreflightPresentCount):hashVerified=$($result.serviceHealthReadback.onlinePreflightHashVerifiedCount):missingArtifacts=$($result.serviceHealthReadback.onlinePreflightMissingArtifactCount):attentionRows=$(@($result.serviceHealthReadback.serviceLifecycleAttentionRows).Count):actionRows=$(@($result.serviceHealthReadback.serviceActionRows).Count):failedChecks=$($result.serviceHealthReadback.serviceExecutionFailedCheckCount):missingChecks=$($result.serviceHealthReadback.serviceExecutionMissingCheckCount):private=$($result.serviceHealthReadback.privateStateExposed)" } + $swarmOnlineRunbook = "none" + if ($null -ne $result.swarmOnlineRunbookReadback -and $null -ne $result.swarmOnlineRunbookReadback.status) { + $swarmOnlineRunbook = "status=$($result.swarmOnlineRunbookReadback.status):childRunbooks=$($result.swarmOnlineRunbookReadback.childRunbookCount):present=$($result.swarmOnlineRunbookReadback.childArtifactPresentCount):hashVerified=$($result.swarmOnlineRunbookReadback.childArtifactHashVerifiedCount):missingArtifacts=$($result.swarmOnlineRunbookReadback.childArtifactMissingCount):failedChecks=$($result.swarmOnlineRunbookReadback.serviceExecutionFailedCheckCount):missingChecks=$($result.swarmOnlineRunbookReadback.serviceExecutionMissingCheckCount):operatorRequired=$($result.swarmOnlineRunbookReadback.elevatedExecutionRequiresOperator):private=$($result.swarmOnlineRunbookReadback.privateStateExposed)" + } $daemonStatus = "none" if ($null -ne $result.daemonStatusReadback -and $null -ne $result.daemonStatusReadback.status) { $daemonStatus = "status=$($result.daemonStatusReadback.status):cluster=$($result.daemonStatusReadback.clusterId):daemon=$($result.daemonStatusReadback.daemonId):surface=$($result.daemonStatusReadback.eveSurfaceId):tools=$($result.daemonStatusReadback.hostedToolCount):private=$($result.daemonStatusReadback.privateStateExposed)" @@ -2140,7 +2144,7 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) { if ($null -ne $result.authorityToolReadback -and $null -ne $result.authorityToolReadback.authorityGate) { $authorityTool = "gate=$($result.authorityToolReadback.authorityGate):input=$($result.authorityToolReadback.inputContractType):receipt=$($result.authorityToolReadback.receiptContractType):host=$($result.authorityToolReadback.hostClusterId):private=$($result.authorityToolReadback.privateStateExposed)" } - Write-Host "Tool invoke: status=$($result.status), requester=$($result.requestingDisplayName), host=$($result.hostDisplayName), tool=$($result.toolName), receipt=$($result.receiptId), daemonStatus=$daemonStatus, eveConnection=$eveConnection, authorityTool=$authorityTool, serviceHealth=$serviceHealth, invocationRows=$invocationRows, privateStateExposed=$($result.privateStateExposed)" + Write-Host "Tool invoke: status=$($result.status), requester=$($result.requestingDisplayName), host=$($result.hostDisplayName), tool=$($result.toolName), receipt=$($result.receiptId), daemonStatus=$daemonStatus, eveConnection=$eveConnection, authorityTool=$authorityTool, serviceHealth=$serviceHealth, swarmOnlineRunbook=$swarmOnlineRunbook, invocationRows=$invocationRows, privateStateExposed=$($result.privateStateExposed)" } elseif ($Mode -eq "swarm-overview" -or $Mode -eq "gjallar") { $attention = "none" if ($null -ne $result.attentionDaemonIds -and $result.attentionDaemonIds.Count -gt 0) {