diff --git a/epiphany-core/src/bin/epiphany-repo-close-mind-adoption-guard-smoke.rs b/epiphany-core/src/bin/epiphany-repo-close-mind-adoption-guard-smoke.rs
index 01aba5e5..12aef538 100644
--- a/epiphany-core/src/bin/epiphany-repo-close-mind-adoption-guard-smoke.rs
+++ b/epiphany-core/src/bin/epiphany-repo-close-mind-adoption-guard-smoke.rs
@@ -457,11 +457,11 @@ fn run_smoke(args: Args) -> Result<Value> {
             map_entry.private_state_exposed
         ));
     }
-    let gjallar = cargo_json(
+    let swarm_overview = cargo_json(
         &manifest,
         "epiphany-verse-query",
         &[
-            "gjallar",
+            "swarm-overview",
             "--store",
             path_str(&local_verse)?,
             "--runtime-id",
@@ -470,48 +470,48 @@ fn run_smoke(args: Args) -> Result<Value> {
         &root,
     )?;
     require_eq(
-        &gjallar,
+        &swarm_overview,
         &["latestRepoWorkMapEntry"],
         "repo-work-map-repo-close-mind-adoption-guard",
     )?;
-    require_bool(&gjallar, &["privateStateExposed"], false)?;
-    let map_rows = value_at_path(&gjallar, &["repoWorkMapRows"])
+    require_bool(&swarm_overview, &["privateStateExposed"], false)?;
+    let map_rows = value_at_path(&swarm_overview, &["repoWorkMapRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapRows array"))?;
-    let gjallar_map_row = map_rows
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapRows array"))?;
+    let swarm_overview_map_row = map_rows
         .iter()
         .find(|row| row.get("item").and_then(Value::as_str) == Some(item))
-        .ok_or_else(|| anyhow!("Gjallar output had no repo work map row for {item}"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo work map row for {item}"))?;
     require_eq_value(
-        gjallar_map_row,
+        swarm_overview_map_row,
         &["safeActionFamily"],
         "repo.markdown_planning_note",
     )?;
     require_eq_value(
-        gjallar_map_row,
+        swarm_overview_map_row,
         &["mindStateCommitReceiptId"],
         &map_entry.mind_state_commit_receipt_id,
     )?;
-    require_bool_value(gjallar_map_row, &["privateStateExposed"], false)?;
-    let map_tui_rows = value_at_path(&gjallar, &["repoWorkMapTuiRows"])
+    require_bool_value(swarm_overview_map_row, &["privateStateExposed"], false)?;
+    let map_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapTuiRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapTuiRows array"))?;
     if !map_tui_rows.iter().any(|row| {
         row.as_str()
             .is_some_and(|row| row.contains("REPO-WORK-MAP") && row.contains(item))
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose compact repo map sight"
+            "Swarm overview TUI rows did not expose compact repo map sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapSemanticCount"], 1)?;
-    let semantic_rows = value_at_path(&gjallar, &["repoWorkMapSemanticRows"])
+    require_u64(&swarm_overview, &["repoWorkMapSemanticCount"], 1)?;
+    let semantic_rows = value_at_path(&swarm_overview, &["repoWorkMapSemanticRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapSemanticRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapSemanticRows array"))?;
     let semantic_row = semantic_rows
         .iter()
         .find(|row| row.get("item").and_then(Value::as_str) == Some(item))
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map semantic row for {item}"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map semantic row for {item}"))?;
     require_eq_value(semantic_row, &["stage"], "imagination-planning")?;
     require_eq_value(semantic_row, &["stageOwner"], "Imagination")?;
     require_eq_value(semantic_row, &["publicationGate"], "Bifrost")?;
@@ -523,9 +523,9 @@ fn run_smoke(args: Args) -> Result<Value> {
     )?;
     require_bool_value(semantic_row, &["sightOnly"], true)?;
     require_bool_value(semantic_row, &["privateStateExposed"], false)?;
-    let semantic_tui_rows = value_at_path(&gjallar, &["repoWorkMapSemanticTuiRows"])
+    let semantic_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapSemanticTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapSemanticTuiRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapSemanticTuiRows array"))?;
     if !semantic_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-SEMANTIC")
@@ -536,20 +536,20 @@ fn run_smoke(args: Args) -> Result<Value> {
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map semantic sight"
+            "Swarm overview TUI rows did not expose repo map semantic sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapFamilyLensCount"], 1)?;
-    let family_lens_rows = value_at_path(&gjallar, &["repoWorkMapFamilyLensRows"])
+    require_u64(&swarm_overview, &["repoWorkMapFamilyLensCount"], 1)?;
+    let family_lens_rows = value_at_path(&swarm_overview, &["repoWorkMapFamilyLensRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapFamilyLensRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapFamilyLensRows array"))?;
     let family_lens_row = family_lens_rows
         .iter()
         .find(|row| {
             row.get("safeActionFamily").and_then(Value::as_str)
                 == Some("repo.markdown_planning_note")
         })
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map family lens row"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map family lens row"))?;
     require_eq_value(family_lens_row, &["latestItem"], item)?;
     require_eq_value(
         family_lens_row,
@@ -557,26 +557,28 @@ fn run_smoke(args: Args) -> Result<Value> {
         &map_entry.mind_state_commit_receipt_id,
     )?;
     require_bool_value(family_lens_row, &["privateStateExposed"], false)?;
-    let family_lens_tui_rows = value_at_path(&gjallar, &["repoWorkMapFamilyLensTuiRows"])
+    let family_lens_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapFamilyLensTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapFamilyLensTuiRows array"))?;
+        .ok_or_else(|| {
+            anyhow!("Swarm overview output had no repoWorkMapFamilyLensTuiRows array")
+        })?;
     if !family_lens_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-LENS") && row.contains("repo.markdown_planning_note")
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map family lens sight"
+            "Swarm overview TUI rows did not expose repo map family lens sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapPathLensCount"], 1)?;
-    let path_lens_rows = value_at_path(&gjallar, &["repoWorkMapPathLensRows"])
+    require_u64(&swarm_overview, &["repoWorkMapPathLensCount"], 1)?;
+    let path_lens_rows = value_at_path(&swarm_overview, &["repoWorkMapPathLensRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapPathLensRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapPathLensRows array"))?;
     let path_lens_row = path_lens_rows
         .iter()
         .find(|row| row.get("path").and_then(Value::as_str) == Some(target_path))
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map path lens row"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map path lens row"))?;
     require_eq_value(path_lens_row, &["latestItem"], item)?;
     require_eq_value(
         path_lens_row,
@@ -584,28 +586,28 @@ fn run_smoke(args: Args) -> Result<Value> {
         &map_entry.mind_state_commit_receipt_id,
     )?;
     require_bool_value(path_lens_row, &["privateStateExposed"], false)?;
-    let path_lens_tui_rows = value_at_path(&gjallar, &["repoWorkMapPathLensTuiRows"])
+    let path_lens_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapPathLensTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapPathLensTuiRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapPathLensTuiRows array"))?;
     if !path_lens_tui_rows.iter().any(|row| {
         row.as_str()
             .is_some_and(|row| row.contains("REPO-WORK-MAP-PATH") && row.contains(target_path))
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map path lens sight"
+            "Swarm overview TUI rows did not expose repo map path lens sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapBranchLensCount"], 1)?;
-    let branch_lens_rows = value_at_path(&gjallar, &["repoWorkMapBranchLensRows"])
+    require_u64(&swarm_overview, &["repoWorkMapBranchLensCount"], 1)?;
+    let branch_lens_rows = value_at_path(&swarm_overview, &["repoWorkMapBranchLensRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapBranchLensRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapBranchLensRows array"))?;
     let branch_lens_row = branch_lens_rows
         .iter()
         .find(|row| {
             row.get("branch").and_then(Value::as_str)
                 == Some("epiphany/repo-close-mind-adoption-guard")
         })
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map branch lens row"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map branch lens row"))?;
     require_eq_value(branch_lens_row, &["latestItem"], item)?;
     require_eq_value(
         branch_lens_row,
@@ -613,9 +615,11 @@ fn run_smoke(args: Args) -> Result<Value> {
         &map_entry.mind_state_commit_receipt_id,
     )?;
     require_bool_value(branch_lens_row, &["privateStateExposed"], false)?;
-    let branch_lens_tui_rows = value_at_path(&gjallar, &["repoWorkMapBranchLensTuiRows"])
+    let branch_lens_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapBranchLensTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapBranchLensTuiRows array"))?;
+        .ok_or_else(|| {
+            anyhow!("Swarm overview output had no repoWorkMapBranchLensTuiRows array")
+        })?;
     if !branch_lens_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-BRANCH")
@@ -623,17 +627,17 @@ fn run_smoke(args: Args) -> Result<Value> {
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map branch lens sight"
+            "Swarm overview TUI rows did not expose repo map branch lens sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapStageLensCount"], 1)?;
-    let stage_lens_rows = value_at_path(&gjallar, &["repoWorkMapStageLensRows"])
+    require_u64(&swarm_overview, &["repoWorkMapStageLensCount"], 1)?;
+    let stage_lens_rows = value_at_path(&swarm_overview, &["repoWorkMapStageLensRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapStageLensRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapStageLensRows array"))?;
     let stage_lens_row = stage_lens_rows
         .iter()
         .find(|row| row.get("stage").and_then(Value::as_str) == Some("imagination-planning"))
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map stage lens row"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map stage lens row"))?;
     require_eq_value(stage_lens_row, &["owner"], "Imagination")?;
     require_eq_value(stage_lens_row, &["latestItem"], item)?;
     require_eq_value(
@@ -642,9 +646,9 @@ fn run_smoke(args: Args) -> Result<Value> {
         &map_entry.mind_state_commit_receipt_id,
     )?;
     require_bool_value(stage_lens_row, &["privateStateExposed"], false)?;
-    let stage_lens_tui_rows = value_at_path(&gjallar, &["repoWorkMapStageLensTuiRows"])
+    let stage_lens_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapStageLensTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapStageLensTuiRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapStageLensTuiRows array"))?;
     if !stage_lens_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-STAGE")
@@ -653,17 +657,17 @@ fn run_smoke(args: Args) -> Result<Value> {
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map stage lens sight"
+            "Swarm overview TUI rows did not expose repo map stage lens sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapGateLensCount"], 1)?;
-    let gate_lens_rows = value_at_path(&gjallar, &["repoWorkMapGateLensRows"])
+    require_u64(&swarm_overview, &["repoWorkMapGateLensCount"], 1)?;
+    let gate_lens_rows = value_at_path(&swarm_overview, &["repoWorkMapGateLensRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapGateLensRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapGateLensRows array"))?;
     let gate_lens_row = gate_lens_rows
         .iter()
         .find(|row| row.get("publicationGate").and_then(Value::as_str) == Some("Bifrost"))
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map gate lens row"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map gate lens row"))?;
     require_eq_value(gate_lens_row, &["owner"], "Bifrost")?;
     require_eq_value(gate_lens_row, &["latestItem"], item)?;
     require_eq_value(
@@ -673,9 +677,9 @@ fn run_smoke(args: Args) -> Result<Value> {
     )?;
     require_bool_value(gate_lens_row, &["sightOnly"], true)?;
     require_bool_value(gate_lens_row, &["privateStateExposed"], false)?;
-    let gate_lens_tui_rows = value_at_path(&gjallar, &["repoWorkMapGateLensTuiRows"])
+    let gate_lens_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapGateLensTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapGateLensTuiRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapGateLensTuiRows array"))?;
     if !gate_lens_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-GATE")
@@ -685,17 +689,17 @@ fn run_smoke(args: Args) -> Result<Value> {
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map gate lens sight"
+            "Swarm overview TUI rows did not expose repo map gate lens sight"
         ));
     }
-    require_u64(&gjallar, &["repoWorkMapClosureCount"], 1)?;
-    let closure_rows = value_at_path(&gjallar, &["repoWorkMapClosureRows"])
+    require_u64(&swarm_overview, &["repoWorkMapClosureCount"], 1)?;
+    let closure_rows = value_at_path(&swarm_overview, &["repoWorkMapClosureRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapClosureRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapClosureRows array"))?;
     let closure_row = closure_rows
         .iter()
         .find(|row| row.get("item").and_then(Value::as_str) == Some(item))
-        .ok_or_else(|| anyhow!("Gjallar output had no repo map closure row"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repo map closure row"))?;
     require_eq_value(
         closure_row,
         &["safeActionFamily"],
@@ -727,9 +731,9 @@ fn run_smoke(args: Args) -> Result<Value> {
     require_bool_value(closure_row, &["crossRepoMutationAuthorized"], false)?;
     require_bool_value(closure_row, &["sightOnly"], true)?;
     require_bool_value(closure_row, &["privateStateExposed"], false)?;
-    let closure_tui_rows = value_at_path(&gjallar, &["repoWorkMapClosureTuiRows"])
+    let closure_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapClosureTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapClosureTuiRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapClosureTuiRows array"))?;
     if !closure_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-CLOSURE")
@@ -743,14 +747,14 @@ fn run_smoke(args: Args) -> Result<Value> {
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map closure sight"
+            "Swarm overview TUI rows did not expose repo map closure sight"
         ));
     }
 
-    require_u64(&gjallar, &["repoWorkMapAcceptanceCount"], 1)?;
-    let acceptance_rows = value_at_path(&gjallar, &["repoWorkMapAcceptanceRows"])
+    require_u64(&swarm_overview, &["repoWorkMapAcceptanceCount"], 1)?;
+    let acceptance_rows = value_at_path(&swarm_overview, &["repoWorkMapAcceptanceRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapAcceptanceRows array"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no repoWorkMapAcceptanceRows array"))?;
     let acceptance_row = acceptance_rows
         .iter()
         .find(|row| {
@@ -758,7 +762,7 @@ fn run_smoke(args: Args) -> Result<Value> {
                 .and_then(Value::as_str)
                 .is_some_and(|value| value == item)
         })
-        .ok_or_else(|| anyhow!("Gjallar output had no acceptance row for {item}"))?;
+        .ok_or_else(|| anyhow!("Swarm overview output had no acceptance row for {item}"))?;
     require_eq_value(
         acceptance_row,
         &["safeActionFamily"],
@@ -794,9 +798,11 @@ fn run_smoke(args: Args) -> Result<Value> {
     require_eq_value(acceptance_row, &["publicationGate"], "Bifrost")?;
     require_bool_value(acceptance_row, &["sightOnly"], true)?;
     require_bool_value(acceptance_row, &["privateStateExposed"], false)?;
-    let acceptance_tui_rows = value_at_path(&gjallar, &["repoWorkMapAcceptanceTuiRows"])
+    let acceptance_tui_rows = value_at_path(&swarm_overview, &["repoWorkMapAcceptanceTuiRows"])
         .and_then(Value::as_array)
-        .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapAcceptanceTuiRows array"))?;
+        .ok_or_else(|| {
+            anyhow!("Swarm overview output had no repoWorkMapAcceptanceTuiRows array")
+        })?;
     if !acceptance_tui_rows.iter().any(|row| {
         row.as_str().is_some_and(|row| {
             row.contains("REPO-WORK-MAP-ACCEPTANCE")
@@ -811,7 +817,7 @@ fn run_smoke(args: Args) -> Result<Value> {
         })
     }) {
         return Err(anyhow!(
-            "Gjallar TUI rows did not expose repo map acceptance sight"
+            "Swarm overview TUI rows did not expose repo map acceptance sight"
         ));
     }
 
@@ -833,16 +839,16 @@ fn run_smoke(args: Args) -> Result<Value> {
         "repoMapEntrySchema": map_entry.schema_version,
         "repoMapDurableStateAdmitted": map_entry.durable_state_admitted,
         "repoMapLocalVerseProjected": true,
-        "gjallarLatestRepoWorkMapEntry": gjallar["latestRepoWorkMapEntry"],
-        "gjallarRepoWorkMapSemanticCount": gjallar["repoWorkMapSemanticCount"],
-        "gjallarRepoWorkMapFamilyLensCount": gjallar["repoWorkMapFamilyLensCount"],
-        "gjallarRepoWorkMapPathLensCount": gjallar["repoWorkMapPathLensCount"],
-        "gjallarRepoWorkMapBranchLensCount": gjallar["repoWorkMapBranchLensCount"],
-        "gjallarRepoWorkMapStageLensCount": gjallar["repoWorkMapStageLensCount"],
-        "gjallarRepoWorkMapGateLensCount": gjallar["repoWorkMapGateLensCount"],
-        "gjallarRepoWorkMapClosureCount": gjallar["repoWorkMapClosureCount"],
-        "gjallarRepoWorkMapAcceptanceCount": gjallar["repoWorkMapAcceptanceCount"],
-        "gjallarRepoWorkMapAcceptanceStatus": acceptance_row["acceptanceStatus"],
+        "swarmOverviewLatestRepoWorkMapEntry": swarm_overview["latestRepoWorkMapEntry"],
+        "swarmOverviewRepoWorkMapSemanticCount": swarm_overview["repoWorkMapSemanticCount"],
+        "swarmOverviewRepoWorkMapFamilyLensCount": swarm_overview["repoWorkMapFamilyLensCount"],
+        "swarmOverviewRepoWorkMapPathLensCount": swarm_overview["repoWorkMapPathLensCount"],
+        "swarmOverviewRepoWorkMapBranchLensCount": swarm_overview["repoWorkMapBranchLensCount"],
+        "swarmOverviewRepoWorkMapStageLensCount": swarm_overview["repoWorkMapStageLensCount"],
+        "swarmOverviewRepoWorkMapGateLensCount": swarm_overview["repoWorkMapGateLensCount"],
+        "swarmOverviewRepoWorkMapClosureCount": swarm_overview["repoWorkMapClosureCount"],
+        "swarmOverviewRepoWorkMapAcceptanceCount": swarm_overview["repoWorkMapAcceptanceCount"],
+        "swarmOverviewRepoWorkMapAcceptanceStatus": acceptance_row["acceptanceStatus"],
         "publicationAuthorized": false,
         "privateStateExposed": false
     });
diff --git a/epiphany-core/src/bin/epiphany-repo-deployment-config-family-smoke.rs b/epiphany-core/src/bin/epiphany-repo-deployment-config-family-smoke.rs
index d17593b5..fe4a8b01 100644
--- a/epiphany-core/src/bin/epiphany-repo-deployment-config-family-smoke.rs
+++ b/epiphany-core/src/bin/epiphany-repo-deployment-config-family-smoke.rs
@@ -291,11 +291,11 @@ fn run_smoke(args: Args) -> Result<Value> {
         ],
         &root,
     )?;
-    let gjallar = cargo_json(
+    let swarm_overview = cargo_json(
         &manifest,
         "epiphany-verse-query",
         &[
-            "gjallar",
+            "swarm-overview",
             "--store",
             path_str(&local_verse)?,
             "--runtime-id",
@@ -474,29 +474,29 @@ fn run_smoke(args: Args) -> Result<Value> {
         "gamecult.idunn.deployment_aftercare_audit.v0",
     )?;
     require_eq(
-        &gjallar,
+        &swarm_overview,
         &["latestIdunnDeploymentReceipt"],
         idunn_deployment_receipt_id,
     )?;
     require_eq(
-        &gjallar,
+        &swarm_overview,
         &["latestIdunnAftercareAuditReceipt"],
         idunn_aftercare_receipt_id,
     )?;
-    require_u64(&gjallar, &["idunnDeploymentReceiptCount"], 2)?;
-    require_bool(&gjallar, &["privateStateExposed"], false)?;
+    require_u64(&swarm_overview, &["idunnDeploymentReceiptCount"], 2)?;
+    require_bool(&swarm_overview, &["privateStateExposed"], false)?;
     require_array_contains(
-        &gjallar,
+        &swarm_overview,
         &["idunnDeploymentReceiptTuiRows"],
         "IDUNN-DEPLOYMENT",
     )?;
     require_array_contains(
-        &gjallar,
+        &swarm_overview,
         &["idunnDeploymentReceiptTuiRows"],
         idunn_deployment_receipt_id,
     )?;
     require_array_contains(
-        &gjallar,
+        &swarm_overview,
         &["idunnDeploymentReceiptTuiRows"],
         idunn_aftercare_receipt_id,
     )?;
@@ -529,9 +529,9 @@ fn run_smoke(args: Args) -> Result<Value> {
         "idunnAftercareAuditReceiptSource": aftercare["idunnAftercareAuditReceipt"]["source"],
         "idunnDeploymentReceiptId": aftercare["idunnDeploymentReceipt"]["receiptId"],
         "idunnAftercareAuditReceiptId": aftercare["idunnAftercareAuditReceipt"]["receiptId"],
-        "gjallarIdunnDeploymentReceiptCount": gjallar["idunnDeploymentReceiptCount"],
-        "gjallarLatestIdunnDeploymentReceipt": gjallar["latestIdunnDeploymentReceipt"],
-        "gjallarLatestIdunnAftercareAuditReceipt": gjallar["latestIdunnAftercareAuditReceipt"],
+        "swarmOverviewIdunnDeploymentReceiptCount": swarm_overview["idunnDeploymentReceiptCount"],
+        "swarmOverviewLatestIdunnDeploymentReceipt": swarm_overview["latestIdunnDeploymentReceipt"],
+        "swarmOverviewLatestIdunnAftercareAuditReceipt": swarm_overview["latestIdunnAftercareAuditReceipt"],
         "deploymentTrigger": "git-push-observed-by-idunn",
         "deploymentOwner": "Idunn",
         "daemonOwnsExecution": true,
diff --git a/epiphany-core/src/bin/epiphany-repo-work-readiness-smoke.rs b/epiphany-core/src/bin/epiphany-repo-work-readiness-smoke.rs
index 1790fc7b..c8cd2b57 100644
--- a/epiphany-core/src/bin/epiphany-repo-work-readiness-smoke.rs
+++ b/epiphany-core/src/bin/epiphany-repo-work-readiness-smoke.rs
@@ -495,11 +495,11 @@ fn run_smoke(args: Args) -> Result<Value> {
     )?;
     require_bool(&readiness_review, &["privateStateExposed"], false)?;
 
-    let gjallar = cargo_json(
+    let swarm_overview = cargo_json(
         &manifest,
         "epiphany-verse-query",
         &[
-            "gjallar",
+            "swarm-overview",
             "--store",
             path_str(&local_verse)?,
             "--runtime-id",
@@ -507,32 +507,36 @@ fn run_smoke(args: Args) -> Result<Value> {
         ],
         &root,
     )?;
-    require_u64(&gjallar, &["repoWorkReadinessCount"], 1)?;
+    require_u64(&swarm_overview, &["repoWorkReadinessCount"], 1)?;
     require_eq(
-        &gjallar,
+        &swarm_overview,
         &["latestRepoWorkReadiness"],
         "repo-work-readiness-repo-work-readiness",
     )?;
-    require_bool(&gjallar, &["privateStateExposed"], false)?;
+    require_bool(&swarm_overview, &["privateStateExposed"], false)?;
     require_tui_row_contains(
-        &gjallar,
+        &swarm_overview,
         &["repoWorkReadinessTuiRows"],
         "REPO-WORK-READINESS",
     )?;
-    require_tui_row_contains(&gjallar, &["swarmActionTuiRows"], "repo-work-readiness")?;
-    require_u64(&gjallar, &["repoWorkReadinessReviewCount"], 1)?;
+    require_tui_row_contains(
+        &swarm_overview,
+        &["swarmActionTuiRows"],
+        "repo-work-readiness",
+    )?;
+    require_u64(&swarm_overview, &["repoWorkReadinessReviewCount"], 1)?;
     require_eq(
-        &gjallar,
+        &swarm_overview,
         &["latestRepoWorkReadinessReview"],
         "repo-work-readiness-review-repo-work-readiness",
     )?;
     require_tui_row_contains(
-        &gjallar,
+        &swarm_overview,
         &["repoWorkReadinessReviewTuiRows"],
         "REPO-WORK-READINESS-REVIEW",
     )?;
     require_tui_row_contains(
-        &gjallar,
+        &swarm_overview,
         &["swarmActionTuiRows"],
         "repo-work-readiness-review",
     )?;
@@ -607,10 +611,10 @@ fn run_smoke(args: Args) -> Result<Value> {
         "readinessReviewVerseProjection": readiness_review["verseProjection"],
         "missingRequiredCount": readiness["missingRequiredCount"],
         "readinessVerseProjection": readiness["verseProjection"],
-        "gjallarRepoWorkReadinessCount": gjallar["repoWorkReadinessCount"],
-        "gjallarLatestRepoWorkReadiness": gjallar["latestRepoWorkReadiness"],
-        "gjallarRepoWorkReadinessReviewCount": gjallar["repoWorkReadinessReviewCount"],
-        "gjallarLatestRepoWorkReadinessReview": gjallar["latestRepoWorkReadinessReview"],
+        "swarmOverviewRepoWorkReadinessCount": swarm_overview["repoWorkReadinessCount"],
+        "swarmOverviewLatestRepoWorkReadiness": swarm_overview["latestRepoWorkReadiness"],
+        "swarmOverviewRepoWorkReadinessReviewCount": swarm_overview["repoWorkReadinessReviewCount"],
+        "swarmOverviewLatestRepoWorkReadinessReview": swarm_overview["latestRepoWorkReadinessReview"],
         "receiptDirectoryRowCount": receipt_directory["rowCount"],
         "receiptDirectoryReadinessReviewRow": receipt_directory_row_value(&receipt_directory, "repo-work-readiness-review")?,
         "bifrostLedgerAccountingRowCount": bifrost_ledger["accountingRowCount"],
diff --git a/epiphany-core/src/bin/epiphany-swarm-stop-classification-smoke.rs b/epiphany-core/src/bin/epiphany-swarm-stop-classification-smoke.rs
index f4ca8382..8dadf0cd 100644
--- a/epiphany-core/src/bin/epiphany-swarm-stop-classification-smoke.rs
+++ b/epiphany-core/src/bin/epiphany-swarm-stop-classification-smoke.rs
@@ -156,7 +156,7 @@ fn run_smoke(args: Args) -> Result<Value> {
         &["stopClassification", "category"],
         "queue-empty",
     )?;
-    require_eq(&empty_run, &["stopClassification", "owner"], "Gjallar")?;
+    require_eq(&empty_run, &["stopClassification", "owner"], "Self")?;
     require_eq(
         &empty_run,
         &["stopClassification", "authorityGate"],
diff --git a/epiphany-core/src/bin/epiphany-swarm.rs b/epiphany-core/src/bin/epiphany-swarm.rs
index 764819c2..f640c20b 100644
--- a/epiphany-core/src/bin/epiphany-swarm.rs
+++ b/epiphany-core/src/bin/epiphany-swarm.rs
@@ -301,7 +301,7 @@ fn run_online(args: OnlineArgs) -> Result<Value> {
             "clusterTopology": topology["schemaVersion"],
             "idunnLiveness": liveness["schemaVersion"],
             "globalToolDirectory": tool_directory["schemaVersion"],
-            "gjallarOverview": overview["schemaVersion"],
+            "swarmOverview": overview["schemaVersion"],
             "privateStateExposed": false
         },
         "nextSafeMove": "Accept a Persona or Bifrost work item into typed Imagination/Self action pressure; the next missing command is epiphany-work accept --workspace <repo>."
@@ -613,7 +613,7 @@ fn classify_run_stop(
             ),
             "blocked-or-noop" if queue_count == 0 => (
                 "queue-empty",
-                "Gjallar",
+                "Self",
                 "repo.work.overview",
                 "no-repo-work-rows",
                 "epiphany-work persona-intake --workspace <repo> --item <id> --message <text>",
diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs
index 2f5302a7..9e5e3fc0 100644
--- a/epiphany-core/src/bin/epiphany-verse-query.rs
+++ b/epiphany-core/src/bin/epiphany-verse-query.rs
@@ -20,13 +20,13 @@ use epiphany_core::EpiphanyCultMeshClusterTopologyEntry;
 use epiphany_core::EpiphanyCultMeshDaemonPokeReceiptEntry;
 use epiphany_core::EpiphanyCultMeshDaemonRestartPolicyEntry;
 use epiphany_core::EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry;
-use epiphany_core::EpiphanyCultMeshManagedServicePolicyEntry;
 use epiphany_core::EpiphanyCultMeshDaemonStatusEntry;
 use epiphany_core::EpiphanyCultMeshDaemonToolCapabilityEntry;
 use epiphany_core::EpiphanyCultMeshEveSurfaceStateEntry;
 use epiphany_core::EpiphanyCultMeshIdunnAftercareAuditReceiptEntry;
 use epiphany_core::EpiphanyCultMeshIdunnDeploymentReceiptEntry;
 use epiphany_core::EpiphanyCultMeshImaginationConsensusReceiptEntry;
+use epiphany_core::EpiphanyCultMeshManagedServicePolicyEntry;
 use epiphany_core::EpiphanyCultMeshOdinAdvertisementEntry;
 use epiphany_core::EpiphanyCultMeshRepoWorkMapEntry;
 use epiphany_core::EpiphanyCultMeshRepoWorkOverviewEntry;
@@ -61,9 +61,9 @@ use epiphany_core::load_epiphany_cultmesh_cluster_topology;
 use epiphany_core::load_epiphany_cultmesh_daemon_liveness;
 use epiphany_core::load_epiphany_cultmesh_daemon_restart_policy_directory;
 use epiphany_core::load_epiphany_cultmesh_daemon_service_lifecycle_receipts;
-use epiphany_core::load_epiphany_cultmesh_managed_service_policies;
 use epiphany_core::load_epiphany_cultmesh_daemon_tool_directory;
 use epiphany_core::load_epiphany_cultmesh_eve_surface_directory;
+use epiphany_core::load_epiphany_cultmesh_managed_service_policies;
 use epiphany_core::load_epiphany_cultmesh_repo_work_map_entries;
 use epiphany_core::load_epiphany_cultmesh_repo_work_overviews;
 use epiphany_core::load_epiphany_cultmesh_repo_work_public_proofs;
@@ -91,8 +91,8 @@ use epiphany_core::load_latest_epiphany_cultmesh_repo_work_overview;
 use epiphany_core::load_latest_epiphany_cultmesh_repo_work_public_proof;
 use epiphany_core::load_latest_epiphany_cultmesh_repo_work_readiness;
 use epiphany_core::load_latest_epiphany_cultmesh_repo_work_readiness_review;
-use epiphany_core::open_epiphany_cultmesh_node;
 use epiphany_core::observe_native_process;
+use epiphany_core::open_epiphany_cultmesh_node;
 use epiphany_core::query_epiphany_local_verse_context;
 use epiphany_core::seed_epiphany_local_verse_context;
 use epiphany_core::write_epiphany_cultmesh_agent_state_soa_summary;
@@ -126,7 +126,6 @@ use std::net::SocketAddr;
 use std::path::PathBuf;
 
 const WRAPPER_OVERVIEW_COMMAND: &str = "tools/epiphany_local_run.ps1 -Mode swarm-overview";
-const WRAPPER_GJALLAR_COMMAND: &str = "tools/epiphany_local_run.ps1 -Mode gjallar";
 const WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND: &str =
     "tools/epiphany_local_run.ps1 -Mode swarm-online-runbook";
 const WRAPPER_POKE_NON_READY_COMMAND: &str = "tools/epiphany_local_run.ps1 -Mode swarm-poke-down";
@@ -334,9 +333,7 @@ fn run_cli() -> Result<()> {
                     "artifactMissingCount": report.artifact_missing_count,
                     "commands": {
                         "overview": "epiphany-verse-query swarm-overview",
-                        "gjallar": "epiphany-verse-query gjallar",
                         "wrapperOverview": WRAPPER_OVERVIEW_COMMAND,
-                        "wrapperGjallar": WRAPPER_GJALLAR_COMMAND,
                         "wrapperSwarmOnlineRunbook": WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND,
                         "tools": "epiphany-verse-query tool-directory",
                         "wrapperTools": "tools/epiphany_local_run.ps1 -Mode tool-directory",
@@ -389,20 +386,22 @@ fn run_cli() -> Result<()> {
                 }))?
             );
         }
-        "managed-services" | "gjallar-managed-services" | "idunn-services" => {
+        "managed-services" | "idunn-services" => {
             let report = managed_service_sight_report(&args.store, &args.runtime_id)?;
-            println!("{}", serde_json::to_string_pretty(&json!({
-                "schemaVersion": "epiphany.cultmesh.managed_service_sight.v0",
-                "status": report.status,
-                "owner": "Gjallar",
-                "lifecycleOwner": "Idunn",
-                "serviceCount": report.rows.len(),
-                "aliveCount": report.alive_count,
-                "attentionCount": report.attention_count,
-                "rows": report.rows,
-                "tuiRows": report.tui_rows,
-                "privateStateExposed": false,
-            }))?);
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&json!({
+                    "schemaVersion": "epiphany.cultmesh.managed_service_sight.v0",
+                    "status": report.status,
+                    "lifecycleOwner": "Idunn",
+                    "serviceCount": report.rows.len(),
+                    "aliveCount": report.alive_count,
+                    "attentionCount": report.attention_count,
+                    "rows": report.rows,
+                    "tuiRows": report.tui_rows,
+                    "privateStateExposed": false,
+                }))?
+            );
         }
         "tools" | "tool-directory" => {
             seed_epiphany_local_verse_context(
@@ -864,7 +863,7 @@ fn run_cli() -> Result<()> {
                 }))?
             );
         }
-        "swarm-overview" | "agent-overview" | "global-agents" | "gjallar" => {
+        "swarm-overview" | "agent-overview" | "global-agents" => {
             seed_epiphany_local_verse_context(
                 &args.store,
                 args.runtime_id.clone(),
@@ -879,12 +878,10 @@ fn run_cli() -> Result<()> {
                 "receipts": "epiphany-verse-query receipt-directory",
                 "restartPolicies": "epiphany-verse-query restart-policy-directory",
                 "repoWorkOverview": "epiphany-work overview --workspace <repo> --item <item>",
-                "repoWorkMap": "epiphany-verse-query gjallar",
+                "repoWorkMap": "epiphany-verse-query swarm-overview",
                 "idunnDeploymentAftercareAudit": DIRECT_IDUNN_DEPLOYMENT_AFTERCARE_AUDIT_COMMAND,
                 "pokeNonReady": "epiphany-verse-query poke-down-daemons",
-                "gjallar": "epiphany-verse-query gjallar",
                 "wrapperOverview": WRAPPER_OVERVIEW_COMMAND,
-                "wrapperGjallar": WRAPPER_GJALLAR_COMMAND,
                 "wrapperSwarmOnlineRunbook": WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND,
                 "wrapperReceipts": WRAPPER_RECEIPT_DIRECTORY_COMMAND,
                 "wrapperRestartPolicies": WRAPPER_SERVICE_POLICY_DIRECTORY_COMMAND,
@@ -2146,7 +2143,6 @@ fn run_cli() -> Result<()> {
                 || !WRAPPER_CONNECT_EVE_COMMAND.contains("-Mode eve-connect")
                 || !WRAPPER_BIFROST_LEDGER_COMMAND.contains("-Mode bifrost-ledger")
                 || !WRAPPER_RECEIPT_DIRECTORY_COMMAND.contains("-Mode receipt-directory")
-                || !WRAPPER_GJALLAR_COMMAND.contains("-Mode gjallar")
                 || !WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND.contains("-Mode swarm-online-runbook")
                 || !WRAPPER_INVOKE_SWARM_ONLINE_RUNBOOK_TOOL_COMMAND.contains("-Mode tool-invoke")
                 || !WRAPPER_INVOKE_SWARM_ONLINE_RUNBOOK_TOOL_COMMAND
@@ -4077,7 +4073,7 @@ fn run_cli() -> Result<()> {
             );
         }
         other => anyhow::bail!(
-            "unknown command {other:?}; use seed, query, provider-advertisements, publish-odin, tools, tool-directory, invoke-tool, restart-policy-directory, swarm-brake, swarm-status, cluster-topology, eve-surfaces, daemon-status, agent-state, agent-state-report, poke-daemon, poke-down-daemons, bifrost-publication, bifrost-public-proof, bifrost-artifact-acceptance, bifrost-metrics, bifrost-ledger, collaboration-feedback, connect-eve, or smoke"
+            "unknown command {other:?}; use seed, query, provider-advertisements, publish-odin, tools, tool-directory, invoke-tool, restart-policy-directory, swarm-brake, swarm-status, swarm-overview, swarm-triage, managed-services, cluster-topology, eve-surfaces, daemon-status, agent-state, agent-state-report, poke-daemon, poke-down-daemons, bifrost-publication, bifrost-public-proof, bifrost-artifact-acceptance, bifrost-metrics, bifrost-ledger, collaboration-feedback, connect-eve, or smoke"
         ),
     }
     Ok(())
@@ -4443,10 +4439,8 @@ fn managed_service_sight_report(
     runtime_id: &str,
 ) -> Result<ManagedServiceSightReport> {
     let policies = load_epiphany_cultmesh_managed_service_policies(store, runtime_id.to_string())?;
-    let lifecycle = load_epiphany_cultmesh_daemon_service_lifecycle_receipts(
-        store,
-        runtime_id.to_string(),
-    )?;
+    let lifecycle =
+        load_epiphany_cultmesh_daemon_service_lifecycle_receipts(store, runtime_id.to_string())?;
     let mut rows = Vec::new();
     for policy in policies {
         let latest = lifecycle
@@ -4469,7 +4463,10 @@ fn managed_service_sight_report(
             process_id,
             lifecycle_receipt_id: latest.map(|receipt| receipt.receipt_id.clone()),
             lifecycle_status: latest.map(|receipt| receipt.status.clone()),
-            last_pulse_status: pulse.as_ref().and_then(|value| value["status"].as_str()).map(str::to_string),
+            last_pulse_status: pulse
+                .as_ref()
+                .and_then(|value| value["status"].as_str())
+                .map(str::to_string),
             last_pulse_iteration: pulse.as_ref().and_then(|value| value["iteration"].as_u64()),
             last_pulse_artifact: pulse
                 .as_ref()
@@ -4506,7 +4503,12 @@ fn managed_service_sight_report(
         })
         .collect();
     Ok(ManagedServiceSightReport {
-        status: if attention_count == 0 { "ready" } else { "attention" }.to_string(),
+        status: if attention_count == 0 {
+            "ready"
+        } else {
+            "attention"
+        }
+        .to_string(),
         alive_count,
         attention_count,
         rows,
@@ -4514,7 +4516,9 @@ fn managed_service_sight_report(
     })
 }
 
-fn compact_last_service_pulse(policy: &EpiphanyCultMeshManagedServicePolicyEntry) -> Option<serde_json::Value> {
+fn compact_last_service_pulse(
+    policy: &EpiphanyCultMeshManagedServicePolicyEntry,
+) -> Option<serde_json::Value> {
     let text = fs::read_to_string(&policy.stdout_artifact).ok()?;
     text.lines()
         .rev()
@@ -5344,9 +5348,7 @@ impl SwarmTriageOutput {
             pokes,
             commands: json!({
                 "overview": "epiphany-verse-query swarm-overview",
-                "gjallar": "epiphany-verse-query gjallar",
                 "wrapperOverview": WRAPPER_OVERVIEW_COMMAND,
-                "wrapperGjallar": WRAPPER_GJALLAR_COMMAND,
                 "wrapperSwarmOnlineRunbook": WRAPPER_SWARM_ONLINE_RUNBOOK_COMMAND,
                 "pokeNonReady": "epiphany-verse-query poke-down-daemons",
                 "wrapperPokeNonReady": WRAPPER_POKE_NON_READY_COMMAND,
@@ -5354,7 +5356,7 @@ impl SwarmTriageOutput {
                 "wrapperReceipts": WRAPPER_RECEIPT_DIRECTORY_COMMAND,
                 "restartPolicies": "epiphany-verse-query restart-policy-directory",
                 "repoWorkOverview": "epiphany-work overview --workspace <repo> --item <item>",
-                "repoWorkMap": "epiphany-verse-query gjallar",
+                "repoWorkMap": "epiphany-verse-query swarm-overview",
                 "idunnDeploymentAftercareAudit": DIRECT_IDUNN_DEPLOYMENT_AFTERCARE_AUDIT_COMMAND,
                 "wrapperRestartPolicies": WRAPPER_SERVICE_POLICY_DIRECTORY_COMMAND,
                 "bifrostLedger": "epiphany-verse-query bifrost-ledger",
@@ -6788,7 +6790,7 @@ fn repo_work_overview_action_row(
         priority,
         family: "repo-work-overview".to_string(),
         status,
-        lifecycle_owner: "Gjallar".to_string(),
+        lifecycle_owner: "none".to_string(),
         hosted_body: "repo-work".to_string(),
         action: format!(
             "Read latest repo work overview {} for item {}.",
@@ -6831,7 +6833,7 @@ fn repo_work_public_proof_action_row(
         priority,
         family: "repo-work-public-proof".to_string(),
         status: proof.current_gate.clone(),
-        lifecycle_owner: "Gjallar".to_string(),
+        lifecycle_owner: "none".to_string(),
         hosted_body: "repo-work".to_string(),
         action: format!(
             "Read redacted public proof {} for item {}; Bifrost owns any public publication or credit consequence.",
@@ -6880,7 +6882,7 @@ fn repo_work_readiness_action_row(
         priority,
         family: "repo-work-readiness".to_string(),
         status: readiness.status.clone(),
-        lifecycle_owner: "Gjallar".to_string(),
+        lifecycle_owner: "none".to_string(),
         hosted_body: "repo-work".to_string(),
         action: format!(
             "Read repo work readiness {} for item {}; Maintainer/Soul/Mind/Bifrost own readiness approval.",
@@ -6936,7 +6938,7 @@ fn repo_work_readiness_review_action_row(
         priority,
         family: "repo-work-readiness-review".to_string(),
         status: review.status.clone(),
-        lifecycle_owner: "Gjallar".to_string(),
+        lifecycle_owner: "none".to_string(),
         hosted_body: "repo-work".to_string(),
         action: format!(
             "Read repo work readiness review {} for item {}; Bifrost/GitHub/Idunn/Hands still own publication, sync, deployment, service lifecycle, and branch consequences.",
diff --git a/epiphany-core/src/bin/epiphany-work.rs b/epiphany-core/src/bin/epiphany-work.rs
index 90eaec48..684323d7 100644
--- a/epiphany-core/src/bin/epiphany-work.rs
+++ b/epiphany-core/src/bin/epiphany-work.rs
@@ -10041,7 +10041,7 @@ fn project_repo_work_map_entry_to_local_verse(
         private_state_exposed: false,
         notes: vec![
             "Repo work map entry is compact local Verse sight over Mind-admitted durable state; raw worker thoughts and receipt payload bodies remain sealed.".to_string(),
-            "Gjallar may project this row, but it does not own scheduling, publication, merge, service lifecycle, deployment, or cross-repo mutation.".to_string(),
+            "Downstream consumers may project this row; the projection grants no scheduling, publication, merge, service lifecycle, deployment, or cross-repo mutation authority.".to_string(),
         ],
     };
     write_epiphany_cultmesh_repo_work_map_entry(local_verse_store, map_entry)
@@ -12661,7 +12661,7 @@ fn run_overview(args: OverviewArgs) -> Result<Value> {
         "intakeConsensus": proof_bundle["intakeConsensus"],
         "rows": rows,
         "authority": {
-            "owner": "Eyes/Gjallar",
+            "owner": "Eyes",
             "sightOnly": true,
             "branchLocalOnly": false,
             "publicationAuthorized": false,
@@ -12702,7 +12702,7 @@ fn run_overview(args: OverviewArgs) -> Result<Value> {
                 notes: vec![
                     "Repo work overview is compact local Verse sight; raw worker thoughts and receipt payload bodies remain sealed.".to_string(),
                     "Persona/public feedback and candidate-action refs are shown only as compact Imagination consensus readback; adoption still requires Mind and Bifrost gates.".to_string(),
-                    "Gjallar/Eve may project these rows, but they do not own scheduling, publication, merge, service lifecycle, or cross-repo mutation.".to_string(),
+                    "downstream Eve lowerers may project these rows, but they do not own scheduling, publication, merge, service lifecycle, or cross-repo mutation.".to_string(),
                 ],
             };
             let written = write_epiphany_cultmesh_repo_work_overview(store, entry)?;
@@ -12821,7 +12821,7 @@ fn run_readiness(args: ReadinessArgs) -> Result<Value> {
         )?,
         readiness_path_row(
             "swarm-online",
-            "Self/Gjallar",
+            "Self",
             "epiphany.repo_swarm_online_receipt.v0",
             &online_receipt_path,
             online_receipt_path.exists(),
@@ -12878,7 +12878,7 @@ fn run_readiness(args: ReadinessArgs) -> Result<Value> {
         safe_family_planning_readiness_row(&close_receipt_path, close_receipt.as_ref()),
         readiness_path_row(
             "public-proof",
-            "Bifrost/Gjallar",
+            "Bifrost",
             "epiphany.repo_work_public_proof_bundle.v0",
             &public_proof_path,
             public_proof_path.exists(),
@@ -13015,7 +13015,7 @@ fn run_readiness(args: ReadinessArgs) -> Result<Value> {
     } else {
         rows.push(readiness_missing_row(
             "tool-directory",
-            "Odin/Gjallar",
+            "Odin",
             "epiphany.cultmesh.daemon_tool_directory.v0",
             "Supply --tool-directory-receipt or run tool-directory sight into the repo work artifact directory.",
         ));
@@ -13145,7 +13145,7 @@ fn run_readiness(args: ReadinessArgs) -> Result<Value> {
                 notes: vec![
                     "Repo work readiness is reviewable sight only; Maintainer/Soul/Mind/Bifrost own any readiness approval.".to_string(),
                     "Bifrost/GitHub own publication and upstream-main sync; Idunn owns service lifecycle; Hands owns branch-local action consequences.".to_string(),
-                    "Gjallar may project these rows without scheduling, publication, merge, deployment, service lifecycle, cross-body mutation, or private Verse authority.".to_string(),
+                    "Downstream consumers may project these rows without scheduling, publication, merge, deployment, service lifecycle, cross-body mutation, or private Verse authority.".to_string(),
                 ],
             };
             let written = write_epiphany_cultmesh_repo_work_readiness(store, entry)?;
@@ -13332,7 +13332,7 @@ fn run_readiness_review(args: ReadinessReviewArgs) -> Result<Value> {
                 tui_rows: review_tui_rows.clone(),
                 notes: vec![
                     "Readiness review approval is review evidence only; it does not publish, merge, deploy, sync upstream, mutate services, or grant Hands authority.".to_string(),
-                    "Maintainer, Soul, Mind, and Bifrost receipts remain the approval authorities; Gjallar only projects this compact row.".to_string(),
+                    "Maintainer, Soul, Mind, and Bifrost receipts remain the approval authorities; The provider sight projection only publishes this compact row.".to_string(),
                 ],
             };
             let written = write_epiphany_cultmesh_repo_work_readiness_review(&store, entry)?;
@@ -14047,7 +14047,7 @@ fn run_export_proof(args: ExportProofArgs) -> Result<Value> {
         private_state_exposed: false,
         notes: vec![
             "Repo work public proof is a redacted local Verse index for public/Bifrost transport; raw receipt bodies, local receipt paths, worker thought, and private Verse contents remain sealed.".to_string(),
-            "Gjallar/Odin may discover this proof, but Bifrost still owns publication, labor ledger, credit, and public consequence.".to_string(),
+            "Odin may discover this proof, but Bifrost still owns publication, labor ledger, credit, and public consequence.".to_string(),
         ],
     };
     let written_public_proof =
@@ -15982,7 +15982,7 @@ fn tool_directory_readiness_row(path: &Path) -> Result<Value> {
 
     Ok(json!({
         "kind": "tool-directory",
-        "owner": "Odin/Gjallar",
+        "owner": "Odin",
         "requiredSchema": "epiphany.cultmesh.daemon_tool_directory.v0",
         "evidenceRef": existing_path_value(path),
         "artifactStatus": if path.exists() { "present" } else { "missing" },
@@ -15998,7 +15998,7 @@ fn tool_directory_readiness_row(path: &Path) -> Result<Value> {
         "privateStateExposed": invariant_private,
         "satisfied": satisfied,
         "status": if satisfied { "satisfied" } else { "missing" },
-        "note": "Odin/Gjallar tool-directory sight proves globally available daemon-hosted tools through typed intents and receipts.",
+        "note": "Odin tool-directory sight proves globally available daemon-hosted tools through typed intents and receipts.",
         "toolExecutionAuthority": false,
         "serviceLifecycleAuthority": false,
         "privateVerseRummagingAuthorized": false
@@ -16231,7 +16231,7 @@ fn repo_work_public_proof_bundle(overview: &Value) -> Result<Value> {
             "privateStateExposed": false
         },
         "authority": {
-            "owner": "Eyes/Gjallar",
+            "owner": "Eyes",
             "sightOnly": true,
             "publicationAuthorized": false,
             "mergeAuthorized": false,
@@ -17297,8 +17297,20 @@ mod authority_tests {
             .status()?;
         assert!(git.success());
         for args in [
-            ["-C", workspace.to_str().unwrap(), "config", "user.name", "Epiphany Smoke"],
-            ["-C", workspace.to_str().unwrap(), "config", "user.email", "smoke@epiphany.invalid"],
+            [
+                "-C",
+                workspace.to_str().unwrap(),
+                "config",
+                "user.name",
+                "Epiphany Smoke",
+            ],
+            [
+                "-C",
+                workspace.to_str().unwrap(),
+                "config",
+                "user.email",
+                "smoke@epiphany.invalid",
+            ],
         ] {
             assert!(Command::new("git").args(args).status()?.success());
         }
@@ -17468,8 +17480,7 @@ mod authority_tests {
                 active_timeout_seconds: 900,
                 dry_run: false,
             })?;
-            let live_receipt =
-                read_json(Path::new(live_tick["receiptPath"].as_str().unwrap()))?;
+            let live_receipt = read_json(Path::new(live_tick["receiptPath"].as_str().unwrap()))?;
             assert_eq!(live_receipt["status"], "modeling-launched");
             assert_eq!(live_receipt["action"], "launch-modeling");
             assert_eq!(
diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs
index 39ac682e..2036eaa5 100644
--- a/epiphany-core/src/cultmesh_integration.rs
+++ b/epiphany-core/src/cultmesh_integration.rs
@@ -4030,9 +4030,13 @@ fn validate_daemon_restart_policy(policy: &EpiphanyCultMeshDaemonRestartPolicyEn
     Ok(())
 }
 
-fn validate_managed_service_policy(policy: &EpiphanyCultMeshManagedServicePolicyEntry) -> Result<()> {
+fn validate_managed_service_policy(
+    policy: &EpiphanyCultMeshManagedServicePolicyEntry,
+) -> Result<()> {
     if policy.private_state_exposed {
-        return Err(anyhow!("managed service policies must not expose private state"));
+        return Err(anyhow!(
+            "managed service policies must not expose private state"
+        ));
     }
     for (label, value) in [
         ("policy id", policy.policy_id.as_str()),
@@ -4048,11 +4052,18 @@ fn validate_managed_service_policy(policy: &EpiphanyCultMeshManagedServicePolicy
             return Err(anyhow!("managed service policy missing {label}"));
         }
     }
-    if !matches!(policy.restart_mode.as_str(), "always" | "on-failure" | "never") {
-        return Err(anyhow!("managed service policy restart_mode must be always, on-failure, or never"));
+    if !matches!(
+        policy.restart_mode.as_str(),
+        "always" | "on-failure" | "never"
+    ) {
+        return Err(anyhow!(
+            "managed service policy restart_mode must be always, on-failure, or never"
+        ));
     }
     if policy.cooldown_seconds < 0 || policy.backoff_multiplier == 0 {
-        return Err(anyhow!("managed service policy requires non-negative cooldown and positive backoff"));
+        return Err(anyhow!(
+            "managed service policy requires non-negative cooldown and positive backoff"
+        ));
     }
     Ok(())
 }
@@ -4587,7 +4598,7 @@ pub fn epiphany_cultmesh_bifrost_public_proof_publication_receipt_for_proof(
         notes: vec![
             "Bifrost public-proof publication receipt binds a redacted repo-work proof bundle to a public Verse room.".to_string(),
             "The receipt carries only proof refs, hashes, ledger, review, and credit ids; private worker/operator/agent state remains sealed.".to_string(),
-            "Gjallar may read this closure, but Bifrost owns public publication authority.".to_string(),
+            "Downstream consumers may read this closure, but Bifrost owns public publication authority.".to_string(),
         ],
     }
 }
@@ -7291,7 +7302,7 @@ pub fn epiphany_cultmesh_bifrost_contracts() -> Vec<EpiphanyCultMeshBifrostContr
                     "CultMesh advertises this Bifrost contract as {EPIPHANY_CULTMESH_BIFROST_CONTRACT_TYPE}."
                 ),
                 "Repo-work public proof bundles are redacted evidence packets, not body changes; Bifrost publishes them into public Verse rooms after review and credit receipts exist.".to_string(),
-                "Gjallar reads the published proof closure, but Bifrost owns public publication authority and ledger attribution.".to_string(),
+                "Downstream consumers may read the published proof closure, but Bifrost owns public publication authority and ledger attribution.".to_string(),
             ],
         },
     ]
diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md
index bd65b0c9..e57264bd 100644
--- a/notes/epiphany-current-algorithmic-map.md
+++ b/notes/epiphany-current-algorithmic-map.md
@@ -241,7 +241,7 @@ liveness. A lane is not relaunched while its prior turn is active. Cooldown
 begins after completion. Idle physiology may ruminate, distill memory, or dream
 without claiming project-state authority.
 
-Idunn owns daemon survival. Self and Gjallar may inspect and recommend; they do
+Idunn owns daemon survival. Self and Downstream consumers may inspect and recommend; they do
 not become alternate daemon keepers.
 
 ## Verse And Interface Projection
@@ -396,18 +396,18 @@ by absent topology restart policies. Live root
 proved PID `44276` was observed alive without duplication, then after forced
 death the next pulse launched PID `40532` under unique receipt
 `daemon-service-lifecycle-receipt-idunn-managed-heartbeat-launch-1783859054234`.
-The next boundary is Gjallar/Eve sight over managed service desired/observed
+The next boundary is provider-owned Eve sight over managed service desired/observed
 state.
 That first sight boundary is now implemented. `observe_native_process` moved
 from the supervisor binary into a shared narrow core organ. Query aliases
-`managed-services`, `gjallar-managed-services`, and `idunn-services` join typed
+`managed-services` and `idunn-services` join typed
 service policy with latest lifecycle history and native observation, then read
 only the compact heartbeat serve pulse line from the sealed stdout artifact.
 Live row PID `25236` transitioned from `READY/alive` to `ATTN/dead` while
 retaining pulse `completed`, iteration `1`, and lifecycle receipt
 `daemon-service-lifecycle-receipt-idunn-managed-heartbeat-launch-1783859373793`.
 No command args or routine payloads are projected. Next merge these rows into
-the main Gjallar/Eve composition rather than keeping a specialist query only.
+the main provider-owned Eve composition rather than keeping a specialist query only.
 
 This map must change when ownership changes. Historical scars belong in git,
 evidence, or an explicitly archived note—not in the machine's proprioception.
diff --git a/notes/epiphany-verse-architecture.md b/notes/epiphany-verse-architecture.md
index 14727f95..73e47a12 100644
--- a/notes/epiphany-verse-architecture.md
+++ b/notes/epiphany-verse-architecture.md
@@ -80,15 +80,6 @@ access receipts, or private-state export rules.
 
 Odin sees the map. Odin does not get to steal the throne.
 
-### Gjallar
-
-Gjallar is Odin's herald: the compact publisher that lets agents and operators
-see the whole Verse surface Odin advertises without opening private state.
-
-Gjallar announces topology, liveness, Eve surfaces, daemon tools, receipt
-attention, and action queues as sealed operator-safe rows. Odin coordinates the
-discovery map; Gjallar carries the horn blast.
-
 ### Yggdrasil
 
 Yggdrasil is the hosting spine for important trusted GameCult Verses.
diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md
index 3f2ed4fd..9faf1a76 100644
--- a/notes/fresh-workspace-handoff.md
+++ b/notes/fresh-workspace-handoff.md
@@ -2253,6 +2253,17 @@ after forced termination, using lifecycle receipt
 No child remains. Next lower this row family into the main Gjallar/Eve
 composition graph and its advertised command/readback surface.
 
+That final paragraph exposed a renderer-ownership fault. Epiphany's local
+`swarm-overview` diagnostic had acquired `gjallar` aliases and false sight/
+lifecycle ownership labels even though the real Gjallar application is a
+downstream Eve compositor. The aliases are now deleted from the Rust CLI and
+PowerShell wrapper; current smoke cargo uses `swarm-overview`; read-only action
+rows carry `lifecycleOwner=none`; and live architecture/state no longer treats
+a downstream renderer as an Epiphany organ. Historical entries above retain
+their original names as evidence. The next cut is simply to publish managed
+service state through Epiphany's standard provider-owned Eve contract, with no
+renderer, layout, or Nightwing knowledge.
+
 ## Immediate Re-entry Instruction
 
 After compaction, first rehydrate and reorient from the listed files and git
diff --git a/notes/perfect-machine-audit-roadmap.md b/notes/perfect-machine-audit-roadmap.md
index 8a137c6e..5776f63b 100644
--- a/notes/perfect-machine-audit-roadmap.md
+++ b/notes/perfect-machine-audit-roadmap.md
@@ -169,16 +169,16 @@ their reconcile reflex independently of standing-daemon topology. Live proof
 observed a heartbeat alive without duplicate launch, killed it, and the next
 Idunn pulse restarted it from the same store with a distinct PID and immutable
 lifecycle receipt. The next gap is inspectability: publish compact managed
-service desired/observed rows through Gjallar/Eve without opening command
+service desired/observed rows through provider-owned Eve without opening command
 payloads or routine artifacts.
 The first sight organ is landed as `epiphany-verse-query
-gjallar-managed-services`. Native process observation now lives in a shared
-core module used by both Idunn reconciliation and Gjallar projection. Rows show
+managed-services`. Native process observation now lives in a shared
+core module used by both Idunn reconciliation and provider sight projection. Rows show
 desired enabled/restart mode, observed alive/dead/missing, PID, latest immutable
 lifecycle receipt, compact last heartbeat pulse status/iteration/artifact, and
 the private-state seal. Live proof transitioned the same row from READY/alive
 to ATTN/dead after a forced process death without exposing command args or
-routine payloads. Next lower this typed row family into the main Gjallar/Eve
+routine payloads. Next lower this typed row family into the main provider-owned Eve
 composition graph.
 
 ### Forbidden writers
diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack
index 6c7a1bcb..cbb4ef01 100644
Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ
diff --git a/state/map.yaml b/state/map.yaml
index 1f8ed4a7..1c80967f 100644
--- a/state/map.yaml
+++ b/state/map.yaml
@@ -70,8 +70,8 @@ data_flow:
     - move historical proof to git, commits, smoke artifacts, or distilled evidence rather than plan prose
 
 active_subgoals:
-  - Gjallar is Odin's herald for whole-Verse sight: Odin coordinates and discovers advertised Verse metadata, while Gjallar publishes compact operator-safe rows for topology, liveness, Eve surfaces, daemon tools, receipts, and action queues without opening private state. The first native Gjallar surface is a read-only alias over the compact swarm overview: `epiphany-verse-query gjallar` and `tools/epiphany_local_run.ps1 -Mode gjallar`.
-  - Idunn owns daemon survival and service lifecycle physiology. Codex/operator sessions may inspect, generate runbooks, and route explicit operator authority, but keeping daemons alive belongs to Idunn-owned service lifecycle receipts, scheduler policy, audits, and aftercare. Do not let Self, Gjallar, or ad hoc wrapper summaries become a second daemon-keeper. Global tool readbacks for Self `service-health`, `service-policy-directory`, and `swarm-online-runbook` now state `lifecycleOwner=Idunn` and `hostedBody=Epiphany` at the top-level operator mouth, with wrapper proofs `local-20260619-034243-246-b5704cd8`, `local-20260619-035238-138-633f3ff0`, and `local-20260619-034148-683-ea6c0ed6` showing the compact `tool-invoke` summaries carry those fields without service mutation or private-state exposure.
+  - `swarm-overview` is an Epiphany-local, renderer-neutral diagnostic projection over provider-owned typed state. It owns no lifecycle, discovery, composition, or mutation authority. Epiphany publishes clean provider-owned Eve surfaces; Odin may discover them; downstream lowerers and compositors remain outside Epiphany's concern.
+  - Idunn owns daemon survival and service lifecycle physiology. Codex/operator sessions may inspect, generate runbooks, and route explicit operator authority, but keeping daemons alive belongs to Idunn-owned service lifecycle receipts, scheduler policy, audits, and aftercare. Do not let Self, diagnostic projections, or ad hoc wrapper summaries become a second daemon-keeper. Global tool readbacks for Self `service-health`, `service-policy-directory`, and `swarm-online-runbook` state `lifecycleOwner=Idunn` and `hostedBody=Epiphany` without service mutation or private-state exposure.
   - Use `notes/epiphany-cultmesh-dreaming-roadmap.md` as the design authority for distributed Epiphany dreaming. Public dreams are separately authored typed documents distributed through CultMesh/CultNet; private state remains local and cannot be shared by flipping a visibility flag. Foreign dreams are external thought weather until a reviewed local adoption receipt digests them into memory, planning, doctrine, or governance.
   - CultMesh is now the preferred ergonomic Rust abstraction over CultCache and CultNet for Epiphany-owned local database surfaces. The Rust substrate is repo-contained under `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`; the old `E:\Projects\CultLib\crates\*` path is dead in this checkout and must not be reintroduced as a compile-time dependency. Future local Verse/dream/status work should start at CultMesh unless it is explicitly polishing CultMesh internals. `CultMeshNode::get_all_with_keys<T>()` now exposes typed document enumeration through the mesh organ, and `CultMeshNode::soa<T>()` exposes CultCache's typed SoA table projection without bypassing the mesh organ. Compact audits can scan local Verse receipt families, and agent-state summary documents now prove SoA readback through CultMesh columns. `epiphany-verse-query agent-state-report` and wrapper `-Mode agent-state-soa` refresh/mirror the persisted seven-row agent-state SoA into local Verse, then emit a compact TUI/JSON report from CultMesh SoA columns without full local Verse serialization. Compact SoA rows now include each standing faculty's role id, agent id, profile kind, portable contract, memory/goal/value counts, and `private=false`; wrapper proof `local-20260618-175913-074-b22ff01c` printed all seven faculties in one sealed line. Preserve the three-Verse boundary: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult project sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Persona posts.
   - Use `notes/epiphany-verse-architecture.md` as the source note for local Verse/Odin/Yggdrasil prompt-context architecture. Odin is the all-seer discovery/coordinator surface for advertised Verse metadata, not a trust-boundary bypass. Yggdrasil is the hosting spine for important trusted GameCult Verses such as Bifrost. The first native local Verse query surface is `epiphany-verse-query`, which seeds/queries compact CultMesh policy/status/contract context for dynamic prompt assembly and operator inspection; `epiphany-prompt-context-smoke` proves that compact local Verse context plus a semantic memory graph context cut can render a bounded dynamic prompt packet, omit unrelated private-looking text, and preserve the packet inside a role worker launch document. Live bridge role/reorient launch paths now feed `dynamicPromptContext` from sibling `local-verse.ccmp` and `memory-graph.msgpack` stores beside runtime-spine, refreshing the memory graph from current typed thread-state repo graphs when absent; the bridge launch-context test proves that packet survives into a persisted runtime-spine worker launch request. `tools/epiphany_local_run.ps1 -Mode status` now uses `.epiphany-run/cultmesh/local-verse.ccmp` as the shared local operator Verse store for run intent, operator snapshot, run receipt, and final `local-verse-context.json`, so the read path sees the latest operator witnesses instead of a policy-only seed packet. Local runs also refresh persisted `epiphany.agent_state_soa.v0` from `state/agents.msgpack` and mirror it into local Verse as sealed `epiphany.cultmesh.agent_state_soa_summary.v0`, preserving seven-faculty row/column shape and contract/count metadata without exposing memory text. `epiphany-verse-query poke-daemon --daemon-id <id>` now records an operator-safe `epiphany.cultmesh.daemon_poke_intent.v0` plus `epiphany.cultmesh.daemon_poke_receipt.v0` in local Verse, so a down daemon has a typed lifecycle intervention path without private Verse rummaging; follow-up daemon status remains the liveness authority. `epiphany-verse-query connect-eve` now selects an Odin advertisement by id or target cluster through the narrow Eve surface directory, records Eve connection intent/receipt documents, and verifies latest receipts through narrow CultMesh loaders; `tools/epiphany_local_run.ps1 -Mode eve-connect` wraps the same receipt path, defaulting to the Persona public discussion surface without full local Verse serialization. `epiphany-verse-query bifrost-publication` now records the Bifrost body-change publication intent, Bifrost publication receipt, and GitHub publication receipt from explicit changed path, verification, review, authorship, credit, ledger, Hands PR, and publication URL inputs, verifies the latest chain through narrow CultMesh loaders, and is wrapped by `tools/epiphany_local_run.ps1 -Mode bifrost-publication` for non-mutating operator proof defaults. `epiphany-verse-query collaboration-feedback` now records public Persona/peer collaboration feedback plus an Imagination consensus-discovery receipt from explicit public refs, Eve receipt, topic, summary, and candidate action refs, verifies latest feedback/consensus through narrow CultMesh loaders, and is wrapped by `tools/epiphany_local_run.ps1 -Mode collaboration-feedback`, which first records the prerequisite Eve receipt; adoption still requires Mind/Bifrost gates. `-Mode mvp` now seeds the same local Verse, routes Persona front-door `bubble` speech audits into that store, and writes final `local-verse-context.json` so the Persona mouth-edge witness is visible beside operator run witnesses. `epiphany-operator-snapshot from-status` now also distills the latest native status `tools.invocations[]` row into local Verse daemon-tool invocation intent/receipt mirrors, so operator-safe runtime tool calls become discoverable as `epiphany.cultmesh.daemon_tool_invocation_*` while runtime-spine remains lifecycle owner and raw MCP JSON stays quarantined behind typed tool documents. Plan/run/MVP coordinator summaries can now mirror their runtime-spine `epiphany.coordinator_run_receipt.v0` into local Verse as `epiphany.cultmesh.coordinator_run_receipt.v0`, referencing sealed artifacts by path only while keeping runtime-spine as lifecycle owner. When that summary contains a `finalAction.handsActionGate`, the same distillation pass writes `epiphany.cultmesh.hands_action_gate.v0` into local Verse with the Hands intent/review ids, Substrate Gate grant id, requested paths, required receipt types, and record-pass command template; runtime-spine Hands/Substrate Gate receipts remain the only action owners. When coordinator steps contain `roleAccept` or `roleFailureReview`, the same pass writes the latest operator-safe `epiphany.cultmesh.role_review_event.v0` mirror with surface, role id, status, source coordinator receipt id, and any exposed acceptance receipt/result/job ids; thread-state acceptance receipts remain the review owner.
@@ -659,4 +659,4 @@ current_status:
   - Service lifecycle receipt history is now event-only: `load_epiphany_cultmesh_daemon_service_lifecycle_receipts` filters out the `epiphany-local/daemon-service-lifecycle-receipt/latest` mirror, while `load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt` remains the latest-state reader. Focused unit test `service_lifecycle_receipt_history_excludes_latest_mirror` proves two per-receipt writes return exactly two history records and latest points at the second. Fresh smoke `verse-query-lifecycle-history-filter-smoke` and live overview/triage `local-20260618-145632-497-efac6f0d` / `local-20260618-145632-321-867947af` prove compact swarm sights still expose service lifecycle attention plus the present elevated runbook artifact without daemon pokes or service mutation. Do not use a broad unscoped cargo test filter for this check on Windows; it fans out across bin harnesses and hit a broken pipe during this pass.
   - `epiphany-verse-query seed-compact` is the compact seed receipt for wrappers and read-only rites. The older `seed` command still prints the full local Verse context for explicit debugging, but compact wrapper modes now avoid full `seed`/final `query` readback after the combined overview proof exposed Windows debug stack overflow from full-context serialization pressure.
   last_completed_repo_swarm_cut: Huginn live-fire has crossed the first real repo Body from Persona pressure to branch-local Hands commit and Soul/Mind closure, and now has repeatable closure and redacted-public-proof mouths. On `E:\Projects\Huginn` branch `epiphany/huginn/first-awakening`, `tools/epiphany_local_run.ps1 -Mode repo-persona-intake` accepted item `huginn-inspection-readback-livefire`, Weksa/Persona intake remained sealed, and `epiphany-work derive-plan` lowered it to model-authored safe family `repo.status_section` for `README.md` only. `tools/epiphany_local_run.ps1 -Mode repo-swarm-run` advanced four bounded pulses: run-from-plan, adopt-from-plan, execute-from-plan, and close-from-execute. Huginn commit `e9b07c38fceabbdc89ea35c2156326c80c0393a2` updated only `README.md`; closure receipt `.epiphany\work\work-close-huginn-inspection-readback-livefire.json` records status `closed`, Soul verdict `passed`, Mind state commit `repo-work-close-huginn-inspection-readback-livefire-mind-commit`, safe family `repo.status_section`, path scope `README.md`, Bifrost publication gate, and `privateStateExposed=false`. Verification also ran Huginn's TypeScript compiler through concrete Node path: `C:\Program Files\nodejs\node.exe E:\Projects\Huginn\node_modules\typescript\bin\tsc -p tsconfig.json` passed. Native verifier `epiphany-repo-livefire-closure-smoke --workspace E:\Projects\Huginn --item huginn-inspection-readback-livefire --expected-path README.md --expected-family repo.status_section --expected-gate awaiting-publication --expected-blocker bifrost-publication-missing` checks closure receipt, Mind map entry, overview gate/blocker, authority seals, and `git show` changed paths, returning `status=ok`, `soulVerdict=passed`, `publicationGate=Bifrost`, and `privateStateExposed=false`. Wrapper `tools/epiphany_local_run.ps1 -Mode repo-livefire-closure -Workspace E:\Projects\Huginn -RepoWorkItem huginn-inspection-readback-livefire -SkipBuild` exposes the same read-only proof through the local operator mouth; artifact `local-20260621-190156-803-2f85ba15` printed commit, path, gate, blocker, Soul verdict, Mind commit receipt, and `privateStateExposed=False` without push, merge, publication, or target mutation. New wrapper `tools/epiphany_local_run.ps1 -Mode repo-work-public-proof -Workspace E:\Projects\Huginn -RepoWorkItem huginn-inspection-readback-livefire -SkipBuild` exports the redacted proof bundle and repo-local Verse index without publishing; artifact `local-20260621-190645-345-4555b1dc` wrote `.epiphany\public\proof-bundles\repo-work-public-proof-huginn-inspection-readback-livefire.json`, proof id `repo-work-public-proof-huginn-inspection-readback-livefire`, SHA-256 `857545b199f3e37eb06c2e757e5cfc201958e46667bb1f8403fd333a22620f63`, nine artifact rows, zero publication rows, and `privateStateExposed=False`. Gjallar readback `local-20260621-190701-140-b9519ec6` sees the `REPO-WORK-PUBLIC-PROOF` row and action row from Huginn's repo-local Verse with the same SHA-256 while Bifrost publication remains missing. Launcher compact modes are now named compact operator-context modes instead of read-only modes, and `bifrost-public-proof` summaries print item, target public Verse, room, proof SHA-256, review receipts, and credit receipts so publication receipts are auditable without claiming upstream sync.
-  next_action: Lower the proven managed-service sight rows into the main Gjallar/Eve composition graph. Reuse the typed `gjallar-managed-services` projection, advertise the readback/Idunn reconcile command through provider-owned Eve state, include READY/ATTN rows in global sight without duplicating policy, and prove browser/TUI lowering sees heartbeat alive/dead transitions with no command args, routine payloads, or private state.
+  next_action: Publish the existing managed-service desired/observed projection as an Epiphany-owned Eve surface using the standard provider contract. Keep `swarm-overview` as a local diagnostic only; do not name or accommodate any downstream compositor, layout, host, or lowering runtime. Prove Odin can discover the provider surface while Epiphany retains no renderer-specific command, schema, owner, or state.
diff --git a/tools/epiphany_local_run.ps1 b/tools/epiphany_local_run.ps1
index 254dfeda..0b1fb28c 100644
--- a/tools/epiphany_local_run.ps1
+++ b/tools/epiphany_local_run.ps1
@@ -1,5 +1,5 @@
 param(
-    [ValidateSet("status", "plan", "smoke", "run", "mvp", "agent-state-soa", "swarm-status", "swarm-poke-down", "swarm-triage", "cluster-topology", "eve-surfaces", "eve-connect", "collaboration-feedback", "persona-discord", "persona-reddit", "persona-other", "persona-bridge", "daemon-survival-rehearsal", "repo-swarm-mvp-gate", "repo-livefire-closure", "bifrost-publication", "bifrost-public-proof", "bifrost-artifact-acceptance", "bifrost-metrics", "bifrost-accounting-bundle", "bifrost-ledger", "receipt-directory", "tool-directory", "tool-invoke", "swarm-overview", "gjallar", "repo-persona-intake", "repo-swarm-run", "repo-work-queue-run", "repo-work-public-proof", "repo-work-readiness", "repo-work-readiness-review", "repo-deployment-config-audit", "repo-deployment-runbook", "repo-deployment-aftercare-audit", "repo-work-service-plan", "repo-work-service-runbook", "repo-work-service-launch", "repo-work-service-audit", "swarm-online-runbook", "service-policy-directory", "service-plan", "service-launch", "service-runbook", "cluster-service-runbook", "cluster-service-install-plan", "cluster-service-install-execute", "cluster-service-audit", "cluster-service-start-plan", "cluster-service-stop-plan", "cluster-service-start-execute", "cluster-service-stop-execute", "cluster-service-execution-readiness", "cluster-service-execution-runbook", "cluster-service-execution-audit", "service-execution-runbook", "service-install-plan", "service-install-execute", "service-tick", "service-status", "service-reconcile", "service-execution-readiness", "service-execution-audit", "service-start-plan", "service-stop-plan", "service-start-execute", "service-stop-execute")]
+    [ValidateSet("status", "plan", "smoke", "run", "mvp", "agent-state-soa", "swarm-status", "swarm-poke-down", "swarm-triage", "cluster-topology", "eve-surfaces", "eve-connect", "collaboration-feedback", "persona-discord", "persona-reddit", "persona-other", "persona-bridge", "daemon-survival-rehearsal", "repo-swarm-mvp-gate", "repo-livefire-closure", "bifrost-publication", "bifrost-public-proof", "bifrost-artifact-acceptance", "bifrost-metrics", "bifrost-accounting-bundle", "bifrost-ledger", "receipt-directory", "tool-directory", "tool-invoke", "swarm-overview", "repo-persona-intake", "repo-swarm-run", "repo-work-queue-run", "repo-work-public-proof", "repo-work-readiness", "repo-work-readiness-review", "repo-deployment-config-audit", "repo-deployment-runbook", "repo-deployment-aftercare-audit", "repo-work-service-plan", "repo-work-service-runbook", "repo-work-service-launch", "repo-work-service-audit", "swarm-online-runbook", "service-policy-directory", "service-plan", "service-launch", "service-runbook", "cluster-service-runbook", "cluster-service-install-plan", "cluster-service-install-execute", "cluster-service-audit", "cluster-service-start-plan", "cluster-service-stop-plan", "cluster-service-start-execute", "cluster-service-stop-execute", "cluster-service-execution-readiness", "cluster-service-execution-runbook", "cluster-service-execution-audit", "service-execution-runbook", "service-install-plan", "service-install-execute", "service-tick", "service-status", "service-reconcile", "service-execution-readiness", "service-execution-audit", "service-start-plan", "service-stop-plan", "service-start-execute", "service-stop-execute")]
     [string]$Mode = "smoke",
     [string]$Root = (Resolve-Path ".").Path,
     [string]$Workspace = "",
@@ -401,7 +401,7 @@ $runtimeStore = Join-Path $Workspace "state\runtime-spine.msgpack"
 $liveRuntimeMode = @("run", "mvp") -contains $Mode
 
 if (-not $SkipBuild) {
-    if ($Mode -ne "status" -and $Mode -ne "agent-state-soa" -and $Mode -ne "swarm-status" -and $Mode -ne "swarm-poke-down" -and $Mode -ne "swarm-triage" -and $Mode -ne "cluster-topology" -and $Mode -ne "eve-surfaces" -and $Mode -ne "eve-connect" -and $Mode -ne "collaboration-feedback" -and $Mode -ne "persona-discord" -and $Mode -ne "persona-reddit" -and $Mode -ne "persona-other" -and $Mode -ne "persona-bridge" -and $Mode -ne "daemon-survival-rehearsal" -and $Mode -ne "repo-swarm-mvp-gate" -and $Mode -ne "repo-livefire-closure" -and $Mode -ne "repo-work-public-proof" -and $Mode -ne "bifrost-publication" -and $Mode -ne "bifrost-public-proof" -and $Mode -ne "bifrost-artifact-acceptance" -and $Mode -ne "bifrost-metrics" -and $Mode -ne "bifrost-accounting-bundle" -and $Mode -ne "bifrost-ledger" -and $Mode -ne "receipt-directory" -and $Mode -ne "tool-directory" -and $Mode -ne "tool-invoke" -and $Mode -ne "swarm-overview" -and $Mode -ne "gjallar" -and $Mode -ne "repo-persona-intake" -and $Mode -ne "repo-swarm-run" -and $Mode -ne "repo-work-queue-run" -and $Mode -ne "repo-work-readiness" -and $Mode -ne "repo-work-readiness-review" -and $Mode -ne "repo-deployment-config-audit" -and $Mode -ne "repo-deployment-runbook" -and $Mode -ne "repo-deployment-aftercare-audit" -and $Mode -ne "repo-work-service-plan" -and $Mode -ne "repo-work-service-runbook" -and $Mode -ne "repo-work-service-launch" -and $Mode -ne "repo-work-service-audit" -and $Mode -ne "swarm-online-runbook" -and $Mode -ne "service-policy-directory" -and $Mode -ne "service-plan" -and $Mode -ne "service-launch" -and $Mode -ne "service-runbook" -and $Mode -ne "cluster-service-runbook" -and $Mode -ne "cluster-service-install-plan" -and $Mode -ne "cluster-service-install-execute" -and $Mode -ne "cluster-service-audit" -and $Mode -ne "cluster-service-start-plan" -and $Mode -ne "cluster-service-stop-plan" -and $Mode -ne "cluster-service-start-execute" -and $Mode -ne "cluster-service-stop-execute" -and $Mode -ne "cluster-service-execution-readiness" -and $Mode -ne "cluster-service-execution-runbook" -and $Mode -ne "cluster-service-execution-audit" -and $Mode -ne "service-execution-runbook" -and $Mode -ne "service-install-plan" -and $Mode -ne "service-install-execute" -and $Mode -ne "service-tick" -and $Mode -ne "service-status" -and $Mode -ne "service-reconcile" -and $Mode -ne "service-execution-readiness" -and $Mode -ne "service-execution-audit" -and $Mode -ne "service-start-plan" -and $Mode -ne "service-stop-plan" -and $Mode -ne "service-start-execute" -and $Mode -ne "service-stop-execute") {
+    if ($Mode -ne "status" -and $Mode -ne "agent-state-soa" -and $Mode -ne "swarm-status" -and $Mode -ne "swarm-poke-down" -and $Mode -ne "swarm-triage" -and $Mode -ne "cluster-topology" -and $Mode -ne "eve-surfaces" -and $Mode -ne "eve-connect" -and $Mode -ne "collaboration-feedback" -and $Mode -ne "persona-discord" -and $Mode -ne "persona-reddit" -and $Mode -ne "persona-other" -and $Mode -ne "persona-bridge" -and $Mode -ne "daemon-survival-rehearsal" -and $Mode -ne "repo-swarm-mvp-gate" -and $Mode -ne "repo-livefire-closure" -and $Mode -ne "repo-work-public-proof" -and $Mode -ne "bifrost-publication" -and $Mode -ne "bifrost-public-proof" -and $Mode -ne "bifrost-artifact-acceptance" -and $Mode -ne "bifrost-metrics" -and $Mode -ne "bifrost-accounting-bundle" -and $Mode -ne "bifrost-ledger" -and $Mode -ne "receipt-directory" -and $Mode -ne "tool-directory" -and $Mode -ne "tool-invoke" -and $Mode -ne "swarm-overview" -and $Mode -ne "repo-persona-intake" -and $Mode -ne "repo-swarm-run" -and $Mode -ne "repo-work-queue-run" -and $Mode -ne "repo-work-readiness" -and $Mode -ne "repo-work-readiness-review" -and $Mode -ne "repo-deployment-config-audit" -and $Mode -ne "repo-deployment-runbook" -and $Mode -ne "repo-deployment-aftercare-audit" -and $Mode -ne "repo-work-service-plan" -and $Mode -ne "repo-work-service-runbook" -and $Mode -ne "repo-work-service-launch" -and $Mode -ne "repo-work-service-audit" -and $Mode -ne "swarm-online-runbook" -and $Mode -ne "service-policy-directory" -and $Mode -ne "service-plan" -and $Mode -ne "service-launch" -and $Mode -ne "service-runbook" -and $Mode -ne "cluster-service-runbook" -and $Mode -ne "cluster-service-install-plan" -and $Mode -ne "cluster-service-install-execute" -and $Mode -ne "cluster-service-audit" -and $Mode -ne "cluster-service-start-plan" -and $Mode -ne "cluster-service-stop-plan" -and $Mode -ne "cluster-service-start-execute" -and $Mode -ne "cluster-service-stop-execute" -and $Mode -ne "cluster-service-execution-readiness" -and $Mode -ne "cluster-service-execution-runbook" -and $Mode -ne "cluster-service-execution-audit" -and $Mode -ne "service-execution-runbook" -and $Mode -ne "service-install-plan" -and $Mode -ne "service-install-execute" -and $Mode -ne "service-tick" -and $Mode -ne "service-status" -and $Mode -ne "service-reconcile" -and $Mode -ne "service-execution-readiness" -and $Mode -ne "service-execution-audit" -and $Mode -ne "service-start-plan" -and $Mode -ne "service-stop-plan" -and $Mode -ne "service-start-execute" -and $Mode -ne "service-stop-execute") {
         Invoke-Checked `
             -Label "build Codex app-server compatibility organ" `
             -FilePath $cargoExe `
@@ -481,7 +481,7 @@ if ($Mode -eq "bifrost-accounting-bundle") {
 if ($Mode -eq "persona-bridge") {
     $requiredBinaries += @($PersonaBridgeSmokeExe)
 }
-if ($Mode -ne "status" -and $Mode -ne "agent-state-soa" -and $Mode -ne "swarm-status" -and $Mode -ne "swarm-poke-down" -and $Mode -ne "swarm-triage" -and $Mode -ne "cluster-topology" -and $Mode -ne "eve-surfaces" -and $Mode -ne "eve-connect" -and $Mode -ne "collaboration-feedback" -and $Mode -ne "persona-discord" -and $Mode -ne "persona-reddit" -and $Mode -ne "persona-other" -and $Mode -ne "persona-bridge" -and $Mode -ne "daemon-survival-rehearsal" -and $Mode -ne "repo-swarm-mvp-gate" -and $Mode -ne "repo-livefire-closure" -and $Mode -ne "repo-work-public-proof" -and $Mode -ne "bifrost-publication" -and $Mode -ne "bifrost-public-proof" -and $Mode -ne "bifrost-artifact-acceptance" -and $Mode -ne "bifrost-metrics" -and $Mode -ne "bifrost-accounting-bundle" -and $Mode -ne "bifrost-ledger" -and $Mode -ne "receipt-directory" -and $Mode -ne "tool-directory" -and $Mode -ne "tool-invoke" -and $Mode -ne "swarm-overview" -and $Mode -ne "gjallar" -and $Mode -ne "repo-persona-intake" -and $Mode -ne "repo-swarm-run" -and $Mode -ne "repo-work-queue-run" -and $Mode -ne "repo-work-readiness" -and $Mode -ne "repo-work-readiness-review" -and $Mode -ne "repo-deployment-config-audit" -and $Mode -ne "repo-deployment-runbook" -and $Mode -ne "repo-deployment-aftercare-audit" -and $Mode -ne "repo-work-service-plan" -and $Mode -ne "repo-work-service-runbook" -and $Mode -ne "repo-work-service-launch" -and $Mode -ne "repo-work-service-audit" -and $Mode -ne "swarm-online-runbook" -and $Mode -ne "service-policy-directory" -and $Mode -ne "service-plan" -and $Mode -ne "service-launch" -and $Mode -ne "service-runbook" -and $Mode -ne "cluster-service-runbook" -and $Mode -ne "cluster-service-install-plan" -and $Mode -ne "cluster-service-install-execute" -and $Mode -ne "cluster-service-audit" -and $Mode -ne "cluster-service-start-plan" -and $Mode -ne "cluster-service-stop-plan" -and $Mode -ne "cluster-service-start-execute" -and $Mode -ne "cluster-service-stop-execute" -and $Mode -ne "cluster-service-execution-readiness" -and $Mode -ne "cluster-service-execution-runbook" -and $Mode -ne "cluster-service-execution-audit" -and $Mode -ne "service-execution-runbook" -and $Mode -ne "service-install-plan" -and $Mode -ne "service-install-execute" -and $Mode -ne "service-tick" -and $Mode -ne "service-status" -and $Mode -ne "service-reconcile" -and $Mode -ne "service-execution-readiness" -and $Mode -ne "service-execution-audit" -and $Mode -ne "service-start-plan" -and $Mode -ne "service-stop-plan" -and $Mode -ne "service-start-execute" -and $Mode -ne "service-stop-execute") {
+if ($Mode -ne "status" -and $Mode -ne "agent-state-soa" -and $Mode -ne "swarm-status" -and $Mode -ne "swarm-poke-down" -and $Mode -ne "swarm-triage" -and $Mode -ne "cluster-topology" -and $Mode -ne "eve-surfaces" -and $Mode -ne "eve-connect" -and $Mode -ne "collaboration-feedback" -and $Mode -ne "persona-discord" -and $Mode -ne "persona-reddit" -and $Mode -ne "persona-other" -and $Mode -ne "persona-bridge" -and $Mode -ne "daemon-survival-rehearsal" -and $Mode -ne "repo-swarm-mvp-gate" -and $Mode -ne "repo-livefire-closure" -and $Mode -ne "repo-work-public-proof" -and $Mode -ne "bifrost-publication" -and $Mode -ne "bifrost-public-proof" -and $Mode -ne "bifrost-artifact-acceptance" -and $Mode -ne "bifrost-metrics" -and $Mode -ne "bifrost-accounting-bundle" -and $Mode -ne "bifrost-ledger" -and $Mode -ne "receipt-directory" -and $Mode -ne "tool-directory" -and $Mode -ne "tool-invoke" -and $Mode -ne "swarm-overview" -and $Mode -ne "repo-persona-intake" -and $Mode -ne "repo-swarm-run" -and $Mode -ne "repo-work-queue-run" -and $Mode -ne "repo-work-readiness" -and $Mode -ne "repo-work-readiness-review" -and $Mode -ne "repo-deployment-config-audit" -and $Mode -ne "repo-deployment-runbook" -and $Mode -ne "repo-deployment-aftercare-audit" -and $Mode -ne "repo-work-service-plan" -and $Mode -ne "repo-work-service-runbook" -and $Mode -ne "repo-work-service-launch" -and $Mode -ne "repo-work-service-audit" -and $Mode -ne "swarm-online-runbook" -and $Mode -ne "service-policy-directory" -and $Mode -ne "service-plan" -and $Mode -ne "service-launch" -and $Mode -ne "service-runbook" -and $Mode -ne "cluster-service-runbook" -and $Mode -ne "cluster-service-install-plan" -and $Mode -ne "cluster-service-install-execute" -and $Mode -ne "cluster-service-audit" -and $Mode -ne "cluster-service-start-plan" -and $Mode -ne "cluster-service-stop-plan" -and $Mode -ne "cluster-service-start-execute" -and $Mode -ne "cluster-service-stop-execute" -and $Mode -ne "cluster-service-execution-readiness" -and $Mode -ne "cluster-service-execution-runbook" -and $Mode -ne "cluster-service-execution-audit" -and $Mode -ne "service-execution-runbook" -and $Mode -ne "service-install-plan" -and $Mode -ne "service-install-execute" -and $Mode -ne "service-tick" -and $Mode -ne "service-status" -and $Mode -ne "service-reconcile" -and $Mode -ne "service-execution-readiness" -and $Mode -ne "service-execution-audit" -and $Mode -ne "service-start-plan" -and $Mode -ne "service-stop-plan" -and $Mode -ne "service-start-execute" -and $Mode -ne "service-stop-execute") {
     $requiredBinaries += @($codexAppServer, $coordinatorExe)
 }
 function Assert-SwarmBrakeAllowsLiveRun {
@@ -653,7 +653,7 @@ Invoke-Checked `
     -StdoutPath (Join-Path $artifactRoot "operator-run-intent.stdout.json") `
     -StderrPath (Join-Path $artifactRoot "operator-run-intent.stderr.log")
 
-$compactOperatorContextModes = @("agent-state-soa", "swarm-status", "swarm-poke-down", "swarm-triage", "cluster-topology", "eve-surfaces", "eve-connect", "collaboration-feedback", "daemon-survival-rehearsal", "repo-swarm-mvp-gate", "repo-livefire-closure", "bifrost-publication", "bifrost-public-proof", "bifrost-artifact-acceptance", "bifrost-metrics", "bifrost-accounting-bundle", "bifrost-ledger", "receipt-directory", "tool-directory", "tool-invoke", "swarm-overview", "gjallar", "swarm-online-runbook", "service-policy-directory")
+$compactOperatorContextModes = @("agent-state-soa", "swarm-status", "swarm-poke-down", "swarm-triage", "cluster-topology", "eve-surfaces", "eve-connect", "collaboration-feedback", "daemon-survival-rehearsal", "repo-swarm-mvp-gate", "repo-livefire-closure", "bifrost-publication", "bifrost-public-proof", "bifrost-artifact-acceptance", "bifrost-metrics", "bifrost-accounting-bundle", "bifrost-ledger", "receipt-directory", "tool-directory", "tool-invoke", "swarm-overview", "swarm-online-runbook", "service-policy-directory")
 $usesCompactOperatorContext = $compactOperatorContextModes -contains $Mode
 $shouldReadLocalVerse = $Mode -ne "smoke" -and -not $usesCompactOperatorContext
 if ($shouldReadLocalVerse -and $Mode -ne "status" -and $Mode -ne "mvp") {
@@ -1279,23 +1279,19 @@ if ($Mode -eq "tool-invoke") {
         -StderrPath (Join-Path $artifactRoot "tool-invoke.stderr.log")
 }
 
-if ($Mode -eq "swarm-overview" -or $Mode -eq "gjallar") {
-    $resultPath = Join-Path $artifactRoot "$Mode.stdout.json"
-    $overviewCommand = "swarm-overview"
-    if ($Mode -eq "gjallar") {
-        $overviewCommand = "gjallar"
-    }
+if ($Mode -eq "swarm-overview") {
+    $resultPath = Join-Path $artifactRoot "swarm-overview.stdout.json"
     Invoke-Checked `
-        -Label "read compact whole-Verse herald overview" `
+        -Label "read compact swarm overview" `
         -FilePath $verseQueryExe `
         -Arguments @(
-            $overviewCommand,
+            "swarm-overview",
             "--store", $localVerseReadStore,
             "--runtime-id", $LocalVerseRuntimeId
         ) `
         -WorkingDirectory $Root `
         -StdoutPath $resultPath `
-        -StderrPath (Join-Path $artifactRoot "$Mode.stderr.log")
+        -StderrPath (Join-Path $artifactRoot "swarm-overview.stderr.log")
 }
 
 if ($Mode -eq "swarm-online-runbook") {
@@ -2974,7 +2970,7 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) {
                 $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, swarmOnlineRunbook=$swarmOnlineRunbook, servicePolicyDirectory=$servicePolicyDirectory, invocationRows=$invocationRows, privateStateExposed=$($result.privateStateExposed)"
-        } elseif ($Mode -eq "swarm-overview" -or $Mode -eq "gjallar") {
+        } elseif ($Mode -eq "swarm-overview") {
             $attention = "none"
             if ($null -ne $result.attentionDaemonIds -and $result.attentionDaemonIds.Count -gt 0) {
                 $attention = ($result.attentionDaemonIds -join ",")
@@ -3078,11 +3074,7 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) {
             if ($null -ne $result.commands -and $null -ne $result.commands.wrapperInvokeSwarmOnlineRunbookTool) {
                 $swarmOnlineTool = $result.commands.wrapperInvokeSwarmOnlineRunbookTool
             }
-            $overviewLabel = "Swarm overview"
-            if ($Mode -eq "gjallar") {
-                $overviewLabel = "Gjallar"
-            }
-            Write-Host "${overviewLabel}: status=$($result.status), liveness=$($result.livenessStatus), recovery=$($result.recoveryStatus), agents=$($result.agentCount), clusters=$($result.clusterCount), privateVerses=$($result.privateVerseCount), surfaces=$($result.surfaceCount), tools=$($result.toolCount), nonReady=$($result.nonReadyDaemonCount), policyMissing=$($result.policyMissingCount), recommended=$($result.recommendedWrapperMode), serviceRecommended=$($result.serviceLifecycleRecommendedWrapperMode), swarmOnlineTool=$swarmOnlineTool, actionQueue=$actionQueue, actionRows=$actionRows, attention=$attention, daemonRows=$daemonRows, toolRows=$toolRows, policyRows=$policyRows, repoWorkMapRows=$repoWorkMapRows, repoWorkSemanticRows=$repoWorkSemanticRows, repoWorkFamilyLensRows=$repoWorkFamilyLensRows, repoWorkPathLensRows=$repoWorkPathLensRows, repoWorkBranchLensRows=$repoWorkBranchLensRows, repoWorkStageLensRows=$repoWorkStageLensRows, repoWorkGateLensRows=$repoWorkGateLensRows, repoWorkClosureRows=$repoWorkClosureRows, repoWorkAcceptanceRows=$repoWorkAcceptanceRows, repoWorkOverviewRows=$repoWorkOverviewRows, repoWorkPublicProofRows=$repoWorkPublicProofRows, repoWorkReadinessRows=$repoWorkReadinessRows, repoWorkReadinessReviewRows=$repoWorkReadinessReviewRows, toolHostAttention=$toolHostAttention, toolAttentionRows=$toolAttentionRows, serviceLifecycleAttention=$serviceLifecycleAttention, serviceAttentionRows=$serviceAttentionRows, serviceExecutionFailedChecks=$serviceExecutionFailedChecks, serviceFailedCheckRows=$serviceFailedCheckRows, privateStateExposed=$($result.privateStateExposed)"
+            Write-Host "Swarm overview: status=$($result.status), liveness=$($result.livenessStatus), recovery=$($result.recoveryStatus), agents=$($result.agentCount), clusters=$($result.clusterCount), privateVerses=$($result.privateVerseCount), surfaces=$($result.surfaceCount), tools=$($result.toolCount), nonReady=$($result.nonReadyDaemonCount), policyMissing=$($result.policyMissingCount), recommended=$($result.recommendedWrapperMode), serviceRecommended=$($result.serviceLifecycleRecommendedWrapperMode), swarmOnlineTool=$swarmOnlineTool, actionQueue=$actionQueue, actionRows=$actionRows, attention=$attention, daemonRows=$daemonRows, toolRows=$toolRows, policyRows=$policyRows, repoWorkMapRows=$repoWorkMapRows, repoWorkSemanticRows=$repoWorkSemanticRows, repoWorkFamilyLensRows=$repoWorkFamilyLensRows, repoWorkPathLensRows=$repoWorkPathLensRows, repoWorkBranchLensRows=$repoWorkBranchLensRows, repoWorkStageLensRows=$repoWorkStageLensRows, repoWorkGateLensRows=$repoWorkGateLensRows, repoWorkClosureRows=$repoWorkClosureRows, repoWorkAcceptanceRows=$repoWorkAcceptanceRows, repoWorkOverviewRows=$repoWorkOverviewRows, repoWorkPublicProofRows=$repoWorkPublicProofRows, repoWorkReadinessRows=$repoWorkReadinessRows, repoWorkReadinessReviewRows=$repoWorkReadinessReviewRows, toolHostAttention=$toolHostAttention, toolAttentionRows=$toolAttentionRows, serviceLifecycleAttention=$serviceLifecycleAttention, serviceAttentionRows=$serviceAttentionRows, serviceExecutionFailedChecks=$serviceExecutionFailedChecks, serviceFailedCheckRows=$serviceFailedCheckRows, privateStateExposed=$($result.privateStateExposed)"
         } elseif ($Mode -eq "repo-persona-intake") {
             $feedbackId = "none"
             $consensusReceiptId = "none"