From fd012d85c6965bc9e1bba2b8d672a116239dbad9 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sat, 20 Jun 2026 22:11:58 +0100 Subject: [PATCH] Add repo work map branch lens --- ...ny-repo-close-mind-adoption-guard-smoke.rs | 32 ++++++ epiphany-core/src/bin/epiphany-verse-query.rs | 96 ++++++++++++++++++ notes/epiphany-repo-swarm-mvp-contract.md | 11 +- notes/fresh-workspace-handoff.md | 1 + state/ledgers.msgpack | Bin 353214 -> 353605 bytes state/map.yaml | 3 +- 6 files changed, 141 insertions(+), 2 deletions(-) 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 6b16ae9a..892fe4e5 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 @@ -559,6 +559,37 @@ fn run_smoke(args: Args) -> Result { "Gjallar TUI rows did not expose repo map path lens sight" )); } + require_u64(&gjallar, &["repoWorkMapBranchLensCount"], 1)?; + let branch_lens_rows = value_at_path(&gjallar, &["repoWorkMapBranchLensRows"]) + .and_then(Value::as_array) + .ok_or_else(|| anyhow!("Gjallar 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"))?; + require_eq_value(branch_lens_row, &["latestItem"], item)?; + require_eq_value( + branch_lens_row, + &["latestMindStateCommitReceiptId"], + &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"]) + .and_then(Value::as_array) + .ok_or_else(|| anyhow!("Gjallar 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") + && row.contains("epiphany/repo-close-mind-adoption-guard") + }) + }) { + return Err(anyhow!( + "Gjallar TUI rows did not expose repo map branch lens sight" + )); + } let summary = json!({ "schemaVersion": "epiphany.repo_close_mind_adoption_guard_smoke.v0", @@ -581,6 +612,7 @@ fn run_smoke(args: Args) -> Result { "gjallarLatestRepoWorkMapEntry": gjallar["latestRepoWorkMapEntry"], "gjallarRepoWorkMapFamilyLensCount": gjallar["repoWorkMapFamilyLensCount"], "gjallarRepoWorkMapPathLensCount": gjallar["repoWorkMapPathLensCount"], + "gjallarRepoWorkMapBranchLensCount": gjallar["repoWorkMapBranchLensCount"], "publicationAuthorized": false, "privateStateExposed": false }); diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs index 929691b7..277df26e 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -4073,6 +4073,8 @@ struct SwarmOverviewReport { repo_work_map_family_lens_tui_rows: Vec, repo_work_map_path_lens_rows: Vec, repo_work_map_path_lens_tui_rows: Vec, + repo_work_map_branch_lens_rows: Vec, + repo_work_map_branch_lens_tui_rows: Vec, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, repo_work_public_proof_rows: Vec, @@ -4156,6 +4158,20 @@ struct RepoWorkMapPathLensRow { private_state_exposed: bool, } +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +struct RepoWorkMapBranchLensRow { + branch: String, + item_count: usize, + changed_path_count: usize, + safe_action_families: Vec, + latest_item: String, + latest_commit_sha: String, + latest_mind_state_commit_receipt_id: String, + publication_gate: String, + private_state_exposed: bool, +} + #[derive(Clone, Serialize)] #[serde(rename_all = "camelCase")] struct RepoWorkPublicProofRow { @@ -4267,6 +4283,9 @@ struct SwarmOverviewOutput { repo_work_map_path_lens_count: usize, repo_work_map_path_lens_rows: Vec, repo_work_map_path_lens_tui_rows: Vec, + repo_work_map_branch_lens_count: usize, + repo_work_map_branch_lens_rows: Vec, + repo_work_map_branch_lens_tui_rows: Vec, repo_work_overview_count: usize, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, @@ -4348,6 +4367,9 @@ impl SwarmOverviewOutput { repo_work_map_path_lens_count: report.repo_work_map_path_lens_rows.len(), repo_work_map_path_lens_rows: report.repo_work_map_path_lens_rows, repo_work_map_path_lens_tui_rows: report.repo_work_map_path_lens_tui_rows, + repo_work_map_branch_lens_count: report.repo_work_map_branch_lens_rows.len(), + repo_work_map_branch_lens_rows: report.repo_work_map_branch_lens_rows, + repo_work_map_branch_lens_tui_rows: report.repo_work_map_branch_lens_tui_rows, repo_work_overview_count: report.repo_work_overview_rows.len(), repo_work_overview_rows: report.repo_work_overview_rows, repo_work_overview_tui_rows: report.repo_work_overview_tui_rows, @@ -4421,6 +4443,9 @@ struct SwarmTriageOutput { repo_work_map_path_lens_count: usize, repo_work_map_path_lens_rows: Vec, repo_work_map_path_lens_tui_rows: Vec, + repo_work_map_branch_lens_count: usize, + repo_work_map_branch_lens_rows: Vec, + repo_work_map_branch_lens_tui_rows: Vec, repo_work_overview_count: usize, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, @@ -4497,6 +4522,9 @@ impl SwarmTriageOutput { repo_work_map_path_lens_count: report.repo_work_map_path_lens_rows.len(), repo_work_map_path_lens_rows: report.repo_work_map_path_lens_rows, repo_work_map_path_lens_tui_rows: report.repo_work_map_path_lens_tui_rows, + repo_work_map_branch_lens_count: report.repo_work_map_branch_lens_rows.len(), + repo_work_map_branch_lens_rows: report.repo_work_map_branch_lens_rows, + repo_work_map_branch_lens_tui_rows: report.repo_work_map_branch_lens_tui_rows, repo_work_overview_count: report.repo_work_overview_rows.len(), repo_work_overview_rows: report.repo_work_overview_rows, repo_work_overview_tui_rows: report.repo_work_overview_tui_rows, @@ -5209,6 +5237,67 @@ fn repo_work_map_path_lens_tui_row(row: &RepoWorkMapPathLensRow) -> String { ) } +fn repo_work_map_branch_lens_rows( + repo_work_map_entries: &[EpiphanyCultMeshRepoWorkMapEntry], +) -> (Vec, Vec) { + let mut by_branch = BTreeMap::::new(); + for entry in repo_work_map_entries { + let branch = entry.branch.clone(); + let row = by_branch + .entry(branch.clone()) + .or_insert_with(|| RepoWorkMapBranchLensRow { + branch, + item_count: 0, + changed_path_count: 0, + safe_action_families: Vec::new(), + latest_item: String::new(), + latest_commit_sha: String::new(), + latest_mind_state_commit_receipt_id: String::new(), + publication_gate: entry.publication_gate.clone(), + private_state_exposed: false, + }); + row.item_count += 1; + row.changed_path_count += entry.changed_paths.len(); + if !row + .safe_action_families + .iter() + .any(|family| family == &entry.safe_action_family) + { + row.safe_action_families + .push(entry.safe_action_family.clone()); + row.safe_action_families.sort(); + } + row.private_state_exposed |= entry.private_state_exposed; + if row.latest_item.is_empty() { + row.latest_item = entry.item.clone(); + row.latest_commit_sha = entry.commit_sha.clone(); + row.latest_mind_state_commit_receipt_id = entry.mind_state_commit_receipt_id.clone(); + row.publication_gate = entry.publication_gate.clone(); + } + } + let rows = by_branch.into_values().collect::>(); + let tui_rows = rows + .iter() + .map(repo_work_map_branch_lens_tui_row) + .collect::>(); + (rows, tui_rows) +} + +fn repo_work_map_branch_lens_tui_row(row: &RepoWorkMapBranchLensRow) -> String { + format!( + "REPO-WORK-MAP-BRANCH | branch={} | items={} | paths={} | families={} | latestItem={} | latestCommit={} | latestMind={} | gate={} | private={}", + row.branch, + row.item_count, + row.changed_path_count, + row.safe_action_families.join(","), + row.latest_item, + short_commit(&row.latest_commit_sha), + row.latest_mind_state_commit_receipt_id, + row.publication_gate, + row.private_state_exposed + ) +} + fn repo_work_peer_tui_rows(rows: &[RepoWorkOverviewRow]) -> Vec { rows.iter() .map(|row| { @@ -6040,6 +6129,8 @@ fn load_swarm_overview_report(args: &Args) -> Result { repo_work_map_family_lens_rows(&repo_work_map_entries); let (repo_work_map_path_lens_rows, repo_work_map_path_lens_tui_rows) = repo_work_map_path_lens_rows(&repo_work_map_entries); + let (repo_work_map_branch_lens_rows, repo_work_map_branch_lens_tui_rows) = + repo_work_map_branch_lens_rows(&repo_work_map_entries); let (repo_work_public_proof_rows, repo_work_public_proof_tui_rows) = repo_work_public_proof_rows(&repo_work_public_proofs); let (swarm_action_rows, swarm_action_tui_rows) = swarm_action_rows( @@ -6070,6 +6161,9 @@ fn load_swarm_overview_report(args: &Args) -> Result { || repo_work_map_path_lens_rows .iter() .any(|row| row.private_state_exposed) + || repo_work_map_branch_lens_rows + .iter() + .any(|row| row.private_state_exposed) || repo_work_public_proofs .iter() .any(|proof| proof.private_state_exposed) @@ -6123,6 +6217,8 @@ fn load_swarm_overview_report(args: &Args) -> Result { repo_work_map_family_lens_tui_rows, repo_work_map_path_lens_rows, repo_work_map_path_lens_tui_rows, + repo_work_map_branch_lens_rows, + repo_work_map_branch_lens_tui_rows, repo_work_overview_rows, repo_work_overview_tui_rows, repo_work_public_proof_rows, diff --git a/notes/epiphany-repo-swarm-mvp-contract.md b/notes/epiphany-repo-swarm-mvp-contract.md index 96056eb8..9f06087c 100644 --- a/notes/epiphany-repo-swarm-mvp-contract.md +++ b/notes/epiphany-repo-swarm-mvp-contract.md @@ -1193,6 +1193,15 @@ Bifrost gate, and `privateStateExposed=false`. This lets agents see which repo paths have accepted branch-local consequences without opening private receipts or giving Gjallar any actuation authority. +The next aggregate lens made the branch workbench explicit: +`.epiphany-smoke\repo-close-mind-adoption-guard-20260620-210747` proves Gjallar +now derives `repoWorkMapBranchLensRows` and `REPO-WORK-MAP-BRANCH` TUI rows from +the same Mind-admitted map entries, grouping by branch with item count, +changed-path count, safe-family list, latest item, latest commit, latest Mind +commit receipt, Bifrost gate, and `privateStateExposed=false`. This lets agents +see which branch owns accepted consequences without making Gjallar a scheduler, +publisher, deployer, daemon keeper, or Mind admission organ. + `epiphany-work overview` is the first compact repo work sight/proof surface: ```powershell @@ -1542,7 +1551,7 @@ temptation wearing clean robes. | Self scheduling | `tick` and `serve` prove one-step branch-local advancement, brake refusal, active-turn refusal, cooldown, and stale-turn recovery; `tick` now routes executed branch-local work through the existing Soul/Modeling/Mind `close` gate; `queue-run` selects tick-actionable rows from the typed repo-work queue and delegates to `tick`; `epiphany-swarm run` is the bounded operator mouth over that queue/tick physiology; `repo-work-service-plan` and `repo-work-service-runbook` write Idunn lifecycle receipts/artifacts for the same queue-run command without launching it. | Keep any future queue-run service launch/install behind Idunn and explicit operator authority. | | Branch-local Hands work | `adopt` and `execute` create approved Hands gates, run planned commands, stage declared paths, commit on `epiphany/*`, and write receipts. | Keep mutation branch-contained and receipt-backed; broaden only through typed plan families, not ad hoc shell freedom. | | Soul/Modeling/Mind closure | `close` verifies the Hands commit, writes `epiphany.repo_work_closure_review.v0`, refuses path-scope mismatches, refuses missing/tampered/non-affirmative Mind adoption proof, runs known safe-family content assertions, optionally gates on model-authored closure verdicts, writes Soul/Modeling/Mind receipts, admits a compact typed repo map entry into `.epiphany/state/repo-work-map.msgpack`, and mirrors that admitted fact into local Verse as `epiphany.cultmesh.repo_work_map_entry.v0`. | Keep extending closure toward source-grounded semantic review and richer semantic map lenses, while preserving deterministic local closure for simple mechanical work. | -| Repo work sight | `overview` emits compact proof rows and mirrors typed `epiphany.cultmesh.repo_work_overview.v0` event documents plus a latest key; `close` mirrors Mind-admitted map facts as `epiphany.cultmesh.repo_work_map_entry.v0`; Gjallar enumerates overview history, map rows, family lens rows, path lens rows, and public-proof rows without private-state exposure; Persona's Eve surface and Eve connection readbacks expose peer-readable gate/blocker/next-action rows; `queue-run` consumes the same overview queue for branch-local scheduler pulses. | Deepen the Persona-to-plan loop and semantic map readback without moving action authority out of Hands/Self/Bifrost. | +| Repo work sight | `overview` emits compact proof rows and mirrors typed `epiphany.cultmesh.repo_work_overview.v0` event documents plus a latest key; `close` mirrors Mind-admitted map facts as `epiphany.cultmesh.repo_work_map_entry.v0`; Gjallar enumerates overview history, map rows, family lens rows, path lens rows, branch lens rows, and public-proof rows without private-state exposure; Persona's Eve surface and Eve connection readbacks expose peer-readable gate/blocker/next-action rows; `queue-run` consumes the same overview queue for branch-local scheduler pulses. | Deepen the Persona-to-plan loop and semantic map readback without moving action authority out of Hands/Self/Bifrost. | | Publication | `publish` routes Bifrost/GitHub receipts from closure or explicit Soul/Mind refs. | Keep publication Bifrost-owned; do not let scheduler publish. | | Upstream main sync | `sync` proves the published commit is contained by upstream main after explicit merge/sync authority. | Treat upstream-main sync as a required final proof for published work. | | Daemon survival | Idunn service lifecycle receipts and runbooks exist outside repo-work tick authority. | Preserve Idunn as lifecycle owner; repo swarm may request or inspect service state, not impersonate daemon keeping. | diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 268dea69..c4326b42 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -125,6 +125,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-20: Durable repo-work map admission now has local Verse/Gjallar sight. `epiphany-work close` still admits the accepted latest-per-item map into `.epiphany/state/repo-work-map.msgpack` only after Soul and Mind pass, then mirrors the accepted fact as `epiphany.cultmesh.repo_work_map_entry.v0` under `gamecult-local/repo-work-map/latest`. `epiphany-verse-query gjallar` now returns `repoWorkMapCount`, `repoWorkMapRows`, `repoWorkMapTuiRows`, and `latestRepoWorkMapEntry`, sealed to safe family, changed-path count, Soul/Mind ids, Bifrost gate, source map store ref, and `privateStateExposed=false`. Proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-203717` shows counterfeit Mind adoption refused without map write, successful close projected the map row, and independent Gjallar readback returned one `REPO-WORK-MAP` row. The outer cargo-run smoke timed out just before child return, but `summary.json` is `status=ok` and the direct Gjallar readback is the terminal proof. The next repo-map work is richer semantic review/map lenses, not first projection. - 2026-06-20: The first repo-work map semantic lens is live in Gjallar. `epiphany-verse-query gjallar` now derives `repoWorkMapFamilyLensCount`, `repoWorkMapFamilyLensRows`, and `repoWorkMapFamilyLensTuiRows` from Mind-admitted `epiphany.cultmesh.repo_work_map_entry.v0` rows, grouping by safe action family with item/path counts, latest item/commit/Mind commit, Bifrost gate, and private-state seal. Smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-205055` reran the counterfeit-adoption guard and proved `gjallarRepoWorkMapFamilyLensCount=1` plus `privateStateExposed=false`. The next map work is deeper source-grounded semantic lenses beyond safe-family aggregation, not basic Gjallar map visibility. - 2026-06-20: Gjallar now has a changed-path lens over Mind-admitted repo-work maps. `repoWorkMapPathLensRows` / `REPO-WORK-MAP-PATH` group accepted map consequences by changed repo path, with item count, safe-family list, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`. Smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-205740` reran the counterfeit-adoption guard and proved `gjallarRepoWorkMapPathLensCount=1` alongside the family lens. The next map work is richer semantic/source-grounded lenses beyond safe-family and path aggregation. +- 2026-06-20: Gjallar now has a branch lens over Mind-admitted repo-work maps. `repoWorkMapBranchLensRows` / `REPO-WORK-MAP-BRANCH` group accepted map consequences by branch with item count, changed-path count, safe-family list, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`. Smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-210747` reran the counterfeit-adoption guard and proved `gjallarRepoWorkMapBranchLensCount=1` alongside the family/path lenses. This is branch-workbench sight only: Gjallar still does not schedule, publish, merge, deploy, keep daemons alive, or admit Mind state. - 2026-06-20: Deeper model-authored closure review is now live. `epiphany-work close` accepts `--closure-model-verdict passed|failed|needs-work|blocked`, `--closure-model-finding`, and `--require-closure-model-verdict`; the close review embeds `epiphany.repo_work_model_closure_review.v0` under `modelingReview.closureReview`, records reviewed inputs and gate enforcement, and Soul refuses closure when a supplied or required model verdict does not pass. Focused smoke `.epiphany-smoke\closure-model-gate-20260620-135103` created a disposable repo, ran two `repo.status_section` items through public front doors, closed one with required model verdict `passed`, and blocked one with `needs-work` while `familyAssertions.status=passed`, `pathScopeMatched=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: Mind adoption/interpreter depth now has a concrete interpretation packet. `epiphany-work adopt` writes `epiphany.repo_work_mind_adoption_decision.v0` before the main adoption receipt, embeds `epiphany.repo_work_mind_interpretation.v0` with input summary, safe-family recognition, requested-path classification, allowed branch-local Hands transition, and forbidden durable-state/publication/service/private transitions, then records Self presentation, Mind evidence review, safe-family requirement, branch-local scope, Bifrost publication gate, Soul closure requirement, and no Hands/durable-state/publication/merge/service/cross-body/private authority inside the Mind decision; the main adoption receipt cites that decision before granting branch-local Hands authority. Focused smoke `.epiphany-smoke\repo-planning-facets-20260620-175503` proves model-authored planning facets survive into Imagination, plan derivation, Mind interpretation, Mind decision, and adoption, while close still passes Soul/family/path checks with `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter semantics beyond the first Mind interpretation packet, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: `repo-manifest` is now the next non-planning safe family. `epiphany-work derive-plan --action-family repo-manifest` lowers accepted pressure into a structured `epiphany.toml` Body manifest with safe family `repo.body_manifest`, body domain, private/local/public Verse ids, Eve surface id, receipt-required capability hints, arbitrary shell sealed false, and private-state seals. Soul closure assertions now inspect the committed manifest for schema, safe family, summary, body domain, Verse ids, Eve surface, receipt requirement, no arbitrary shell, and private-state seals. Focused smoke `.epiphany-smoke\repo-manifest-family-20260620-141552` ran a disposable repo through init -> online -> accept -> repo-manifest derive-plan -> tick run/adopt/execute/close; Hands committed only `epiphany.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, additional useful repo-owned config/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index f5064335f7eb37aba237b2e40e5c3717f9eb2d84..7a764762fe746433698dee3bd6d2c96612ab8056 100644 GIT binary patch delta 239 zcmdmYT=eKE(G3!e+=hl$hUQVn7+6!3HY+n0GBO4=Pi1PK%ESo7AetG7S+-AQV%1EX zzTgrIFRKwygW>dvA6TTM86(}Z5_57Aixl$m%N0^mi!#enixrZJ67!O$pH5rDm2W_-5v%=q9G*7nEe?=K%P>@qvtdN$No0(Io VUyxXmp^yWVgjiTSJ<*L>9sp6_QU?G4 delta 53 zcmX?lN_5|G(G3!e+y(|#h89uB7+8~LZ&qe3WMm9%p32ldm5C9EK{PWEvuvNr#HyJH E0NI-mOaK4? diff --git a/state/map.yaml b/state/map.yaml index 444162c8..fd1c29a8 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -92,6 +92,7 @@ active_subgoals: - Mind-admitted repo-work map facts now leave local Verse sight. Successful `epiphany-work close` first admits `.epiphany/state/repo-work-map.msgpack` as `epiphany.repo_work_map_store.v0`, then mirrors the accepted item fact into local Verse as `epiphany.cultmesh.repo_work_map_entry.v0` under `gamecult-local/repo-work-map/latest`. `epiphany-verse-query gjallar` exposes `repoWorkMapRows`, `repoWorkMapTuiRows`, and `latestRepoWorkMapEntry` with safe family, changed-path count, Soul verdict id, Mind review/commit ids, Bifrost gate, source map store ref, and `privateStateExposed=false`; proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-203717` plus direct Gjallar readback showed one compact `REPO-WORK-MAP` row after counterfeit Mind adoption was refused and the real close passed. This is sight only; Gjallar still does not schedule, publish, merge, deploy, keep daemons alive, or open private state. - Gjallar now derives the first repo-work map semantic lens from Mind-admitted local Verse map rows. `repoWorkMapFamilyLensRows` / `REPO-WORK-MAP-LENS` group accepted repo-work consequences by safe action family, with item count, changed-path count, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`; proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-205055` reran the counterfeit-adoption guard and passed with `gjallarRepoWorkMapFamilyLensCount=1`. This is aggregate sight only, not scheduling, publication, merge, deployment, service lifecycle, or Mind admission authority. - Gjallar now derives a changed-path repo-work map lens from the same Mind-admitted local Verse rows. `repoWorkMapPathLensRows` / `REPO-WORK-MAP-PATH` group accepted consequences by changed repo path, with item count, safe-family list, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`; proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-205740` passed with `gjallarRepoWorkMapPathLensCount=1` beside the family lens. This lets agents see which Body paths have accepted work without opening private receipts or granting Gjallar actuation authority. + - Gjallar now derives a branch-workbench repo-work map lens from the same Mind-admitted local Verse rows. `repoWorkMapBranchLensRows` / `REPO-WORK-MAP-BRANCH` group accepted consequences by branch, with item count, changed-path count, safe-family list, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`; proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-210747` passed with `gjallarRepoWorkMapBranchLensCount=1` beside the family/path lenses. This lets agents see which branch owns accepted consequences without opening private receipts or granting Gjallar scheduling, publication, deployment, lifecycle, or Mind admission authority. - Gjallar/swarm-overview now projects typed repo-work overview history into the compact global sight report, Persona's public Eve surface lowers the same queue for peers, and Self has a first runnable queue surface over it. `epiphany-verse-query gjallar` reads all `epiphany.cultmesh.repo_work_overview.v0` event documents from local Verse, excludes the `latest` mirror, preserves latest scalar fields, emits multi-item `repoWorkOverviewRows`/TUI rows, and publishes bounded priority 35-39 non-mutating `repo-work-overview` action rows with `owner=Gjallar`, `hostedBody=repo-work`, `authorityGate=repo.work.overview`, `mutatesState=false`, `requiresElevatedAuthority=false`, proof-bundle refs, current gate/blocker/next-safe-move, and `privateStateExposed=false`. `epiphany-verse-query eve-surfaces`, `connect-eve`, and globally invokable Persona `eve-connect` tool readbacks expose compact `REPO-WORK-PEER` rows with item, gate, blocker, next safe move, branch, publication/sync state, and private seal for the public Persona surface only. `epiphany-work queue-run` selects current-repo rows at `ready-to-run`, `ready-to-adopt`, or `ready-to-execute`, delegates action to `tick`, refreshes overview after real advancement, and writes `epiphany.repo_work_queue_run_receipt.v0`; wrapper mode `tools/epiphany_local_run.ps1 -Mode repo-work-queue-run` exposes the same surface. Disposable proofs `.epiphany-smoke\gjallar-repo-work-queue-20260620-012027`, `.epiphany-smoke\eve-repo-work-queue-20260620-013322`, `.epiphany-smoke\queue-run-20260620-014314`, and wrapper artifact `local-20260620-014627-174-aada0241` showed two-item queues through sight, public Eve, direct queue-run, and wrapper dry-run without publication, merge, service lifecycle mutation, elevation, cross-repo mutation, or private-state exposure. - Agent memory lifecycle now has a first typed v0 operation surface in `epiphany-core::agent_memory`: `AgentMemoryLifecycleOperation` can revise, retire, crystallize, prune, and merge bounded memory records after role/agent review, and `epiphany-agent-memory-store review-lifecycle|apply-lifecycle` exposes the path at the operator edge. This closes the first explicit lifecycle-operation slice from the swarm-readiness gate; it does not yet make sleep silently mutate identity or project truth. - Persona public speech now has a parent-side eligibility receipt at the Discord/Aquarium mouth edge. `epiphany.persona_speech_audit.v0` records action kind, content fingerprint, opening/topic keys, recent-window counts, repeated opening/topic counts, channel saturation, and allow/block reasons. `epiphany-persona-discord post` blocks repeated public openings before token/webhook work; draft and bubble still emit audit receipts for operator inspection. The compatibility JSON artifact remains for display, but the durable witness is now `epiphany.cultmesh.persona_speech_audit.v0` in CultMesh with latest-key projection through local Verse context. Local MVP Persona bubbles now write that durable witness to `.epiphany-run/cultmesh/local-verse.ccmp`, not a separate mouth-side store. This is posting-edge policy, not a Persona prompt wish. @@ -637,5 +638,5 @@ current_status: - `tools/epiphany_local_run.ps1 -Mode swarm-online-runbook` now emits an explicit Idunn preflight summary before the operator elevation boundary. Its JSON and one-line summary report `preflightStatus`, child artifact present/hash-verified/mismatch/missing counts, aggregate service execution failed/missing check counts, child preflight rows with expected/actual SHA-256s, and private-state exposure. Live proof `local-20260619-025627-410-9724e2f6` generated the non-mutating parent artifact with `preflightStatus=ready-for-elevated-operator`, two child runbooks present, two hashes verified, zero mismatches, zero missing artifacts, eleven failed sealed service checks, zero missing checks, explicit aftercare audits, and `privateStateExposed=false`. The remaining scar is still explicit elevated operator execution followed by complete Idunn audits, not missing parent/child artifact readiness. - 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: Gjallar now derives a changed-path semantic lens over Mind-admitted repo-work map rows. `epiphany-verse-query gjallar` exposes `repoWorkMapPathLensRows` / `REPO-WORK-MAP-PATH`, grouping accepted consequences by changed repo path with item count, safe-family list, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`. Proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-205740` reran the counterfeit Mind-adoption guard, closed the original chain, projected the local Verse map row, and passed with `gjallarRepoWorkMapPathLensCount=1`. + last_completed_repo_swarm_cut: Gjallar now derives a branch-workbench semantic lens over Mind-admitted repo-work map rows. `epiphany-verse-query gjallar` exposes `repoWorkMapBranchLensRows` / `REPO-WORK-MAP-BRANCH`, grouping accepted consequences by branch with item count, changed-path count, safe-family list, latest item/commit/Mind commit, Bifrost gate, and `privateStateExposed=false`. Proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-210747` reran the counterfeit Mind-adoption guard, closed the original chain, projected the local Verse map row, and passed with `gjallarRepoWorkMapBranchLensCount=1` beside the family/path lenses. next_action: Continue repo-swarm MVP work from the documented Epiphany Online cut order in `notes/epiphany-repo-swarm-mvp-contract.md`. Typed Gjallar repo-work history/queue sight, peer-readable Persona Eve lowering, Self-owned `epiphany-work queue-run`, bounded `epiphany-swarm run`, execute-to-close scheduler handoff through `close-from-execute`, deterministic `derive-plan` families `append-worklog`, `planning-note`, `checklist-note`, `section-note` / `repo.markdown_managed_section`, `task-card` / `repo.task_card`, `repo-status-section` / `repo.status_section`, `repo-manifest` / `repo.body_manifest`, `repo-tool-capabilities` / `repo.tool_capabilities`, `repo-tool-request` / `repo.tool_request`, `repo-eve-surface` / `repo.eve_surface`, `repo-collaboration-policy` / `repo.collaboration_policy`, `repo-collaboration-topic` / `repo.collaboration_topic`, `repo-consensus-brief` / `repo.consensus_brief`, `repo-objective-draft` / `repo.objective_draft`, `repo-adoption-request` / `repo.adoption_request`, `repo-scheduling-request` / `repo.scheduling_request`, `repo-work-order` / `repo.work_order`, `repo-verification-request` / `repo.verification_request`, `repo-publication-request` / `repo.publication_request`, `repo-sync-request` / `repo.sync_request`, `repo-maintainer-review-request` / `repo.maintainer_review_request`, `repo-pr-request` / `repo.pr_request`, `repo-credit-request` / `repo.credit_request`, `repo-artifact-acceptance-request` / `repo.artifact_acceptance_request`, `repo-metrics-request` / `repo.metrics_request`, `repo-doctrine-update-request` / `repo.doctrine_update_request`, `repo-secret-policy-request` / `repo.secret_policy_request`, and `repo-deployment-request` / `repo.deployment_request`, typed Imagination action-item receipts over allowlisted safe families, `epiphany.repo_work_mind_interpretation.v0` plus `epiphany.repo_work_mind_adoption_decision.v0` Mind interpreter receipts, explicit safe-family allowlist refusal, explicit requested-path/plan-changed-path mismatch refusal, Soul closure's Mind-adoption proof guard, durable repo-work map admission before branch-local Hands consequences reach publication gates, local Verse `epiphany.cultmesh.repo_work_map_entry.v0` Gjallar readback for Mind-admitted map facts, hash-backed local proof bundles with Bifrost/GitHub/credit/PR/upstream-main publication rows, redacted `epiphany-work export-proof` public bundles plus local Verse `epiphany.cultmesh.repo_work_public_proof.v0` Gjallar readback, Bifrost-owned `gamecult.bifrost.public_proof_publication_receipt.v0` closure plus wrapper `bifrost-public-proof` for redacted public proofs, Idunn-hosted non-mutating queue-run lifecycle plan/runbook receipts including native proof `.epiphany-smoke\repo-work-service-lifecycle-20260620-185853`, and the speech-audited `epiphany-work persona-intake` mouth plus wrapper `repo-persona-intake` are live with `privateStateExposed=false`; proofs `.epiphany-smoke\fresh-repo-mvp-20260620-180024`, `.epiphany-smoke\swarm-stop-classification-20260620-184717`, `.epiphany-smoke\repo-mind-safe-family-guard-20260620-194425`, `.epiphany-smoke\repo-mind-path-guard-20260620-194239`, `.epiphany-smoke\repo-doctrine-update-request-family-20260620-192140`, `.epiphany-smoke\repo-secret-policy-request-family-20260620-193046`, `.epiphany-smoke\repo-deployment-request-family-20260620-195605`, `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-201153`, `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-202113`, and `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-203717` show fresh-repo iteration-limit stop classification, empty-queue Gjallar classification, dry-run planning-preview Self classification, Bifrost publication-gate classification, Bifrost/GitHub upstream-sync gate classification, Mind refusal for unsupported safe-family cargo and mismatched requested paths, reviewed doctrine/security/deployment request cargo, closure refusal for counterfeit Mind adoption, durable repo-map admission only after passing closure, local Verse/Gjallar map projection, closure, publication receipts, upstream-main sync, public-proof export, and private-state sealing. The contract note now explicitly answers that Epiphany is headed toward a functional repo swarm but is not fully online until the typed artery runs as a living repo organism. The next cut is deeper semantic review/map lenses, further useful repo-owned config/action request families, or explicit Idunn deployment execution/audit under operator authority. Preserve Idunn service lifecycle ownership and existing CultMesh/Odin/Eve tool directories; service install/start/deployment execution still requires explicit elevated operator authority.