From 6811ff7ea6735c56d04bc9adc0d29db259e8dc52 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sun, 21 Jun 2026 09:27:13 +0100 Subject: [PATCH] Add Gjallar repo work acceptance lens --- ...ny-repo-close-mind-adoption-guard-smoke.rs | 66 ++++++++++ epiphany-core/src/bin/epiphany-verse-query.rs | 115 ++++++++++++++++++ notes/epiphany-repo-swarm-mvp-contract.md | 18 +++ notes/fresh-workspace-handoff.md | 1 + state/ledgers.msgpack | Bin 363420 -> 363941 bytes state/map.yaml | 1 + tools/epiphany_local_run.ps1 | 6 +- 7 files changed, 205 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 45ac8e6c..4c59eae2 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 @@ -745,6 +745,70 @@ fn run_smoke(args: Args) -> Result { )); } + require_u64(&gjallar, &["repoWorkMapAcceptanceCount"], 1)?; + let acceptance_rows = value_at_path(&gjallar, &["repoWorkMapAcceptanceRows"]) + .and_then(Value::as_array) + .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapAcceptanceRows array"))?; + let acceptance_row = acceptance_rows + .iter() + .find(|row| { + value_at_path(row, &["item"]) + .and_then(Value::as_str) + .is_some_and(|value| value == item) + }) + .ok_or_else(|| anyhow!("Gjallar output had no acceptance row for {item}"))?; + require_eq_value(acceptance_row, &["safeActionFamily"], "repo.markdown_planning_note")?; + require_eq_value( + acceptance_row, + &["acceptanceStatus"], + "accepted-awaiting-publication-gate", + )?; + require_bool_value(acceptance_row, &["soulClosed"], true)?; + require_bool_value(acceptance_row, &["modelingClosed"], true)?; + require_bool_value(acceptance_row, &["mindCommitted"], true)?; + require_bool_value(acceptance_row, &["durableStateAdmitted"], true)?; + require_bool_value(acceptance_row, &["bifrostGateNamed"], true)?; + require_eq_value( + acceptance_row, + &["soulVerdictReceiptId"], + close["soul"]["verdictReceiptId"] + .as_str() + .unwrap_or(""), + )?; + require_eq_value( + acceptance_row, + &["mindGatewayReviewId"], + &map_entry.mind_gateway_review_id, + )?; + require_eq_value( + acceptance_row, + &["mindStateCommitReceiptId"], + &map_entry.mind_state_commit_receipt_id, + )?; + 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"]) + .and_then(Value::as_array) + .ok_or_else(|| anyhow!("Gjallar 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") + && row.contains("status=accepted-awaiting-publication-gate") + && row.contains("soulClosed=true") + && row.contains("modelingClosed=true") + && row.contains("mindCommitted=true") + && row.contains("durableAdmitted=true") + && row.contains("publicationGate=Bifrost") + && row.contains("bifrostGateNamed=true") + && row.contains("sightOnly=true") + }) + }) { + return Err(anyhow!( + "Gjallar TUI rows did not expose repo map acceptance sight" + )); + } + let summary = json!({ "schemaVersion": "epiphany.repo_close_mind_adoption_guard_smoke.v0", "status": "ok", @@ -771,6 +835,8 @@ fn run_smoke(args: Args) -> Result { "gjallarRepoWorkMapStageLensCount": gjallar["repoWorkMapStageLensCount"], "gjallarRepoWorkMapGateLensCount": gjallar["repoWorkMapGateLensCount"], "gjallarRepoWorkMapClosureCount": gjallar["repoWorkMapClosureCount"], + "gjallarRepoWorkMapAcceptanceCount": gjallar["repoWorkMapAcceptanceCount"], + "gjallarRepoWorkMapAcceptanceStatus": acceptance_row["acceptanceStatus"], "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 f0c1cb4b..22058e9a 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -4117,6 +4117,8 @@ struct SwarmOverviewReport { repo_work_map_gate_lens_tui_rows: Vec, repo_work_map_closure_rows: Vec, repo_work_map_closure_tui_rows: Vec, + repo_work_map_acceptance_rows: Vec, + repo_work_map_acceptance_tui_rows: Vec, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, repo_work_public_proof_rows: Vec, @@ -4289,6 +4291,27 @@ struct RepoWorkMapClosureRow { private_state_exposed: bool, } +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +struct RepoWorkMapAcceptanceRow { + item: String, + branch: String, + safe_action_family: String, + acceptance_status: String, + soul_closed: bool, + modeling_closed: bool, + mind_committed: bool, + durable_state_admitted: bool, + bifrost_gate_named: bool, + soul_verdict_receipt_id: String, + modeling_summary: String, + mind_gateway_review_id: String, + mind_state_commit_receipt_id: String, + publication_gate: String, + sight_only: bool, + private_state_exposed: bool, +} + #[derive(Clone, Serialize)] #[serde(rename_all = "camelCase")] struct RepoWorkPublicProofRow { @@ -4433,6 +4456,9 @@ struct SwarmOverviewOutput { repo_work_map_closure_count: usize, repo_work_map_closure_rows: Vec, repo_work_map_closure_tui_rows: Vec, + repo_work_map_acceptance_count: usize, + repo_work_map_acceptance_rows: Vec, + repo_work_map_acceptance_tui_rows: Vec, repo_work_overview_count: usize, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, @@ -4534,6 +4560,9 @@ impl SwarmOverviewOutput { repo_work_map_closure_count: report.repo_work_map_closure_rows.len(), repo_work_map_closure_rows: report.repo_work_map_closure_rows, repo_work_map_closure_tui_rows: report.repo_work_map_closure_tui_rows, + repo_work_map_acceptance_count: report.repo_work_map_acceptance_rows.len(), + repo_work_map_acceptance_rows: report.repo_work_map_acceptance_rows, + repo_work_map_acceptance_tui_rows: report.repo_work_map_acceptance_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, @@ -4627,6 +4656,9 @@ struct SwarmTriageOutput { repo_work_map_closure_count: usize, repo_work_map_closure_rows: Vec, repo_work_map_closure_tui_rows: Vec, + repo_work_map_acceptance_count: usize, + repo_work_map_acceptance_rows: Vec, + repo_work_map_acceptance_tui_rows: Vec, repo_work_overview_count: usize, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, @@ -4723,6 +4755,9 @@ impl SwarmTriageOutput { repo_work_map_closure_count: report.repo_work_map_closure_rows.len(), repo_work_map_closure_rows: report.repo_work_map_closure_rows, repo_work_map_closure_tui_rows: report.repo_work_map_closure_tui_rows, + repo_work_map_acceptance_count: report.repo_work_map_acceptance_rows.len(), + repo_work_map_acceptance_rows: report.repo_work_map_acceptance_rows, + repo_work_map_acceptance_tui_rows: report.repo_work_map_acceptance_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, @@ -5826,6 +5861,79 @@ fn repo_work_map_closure_tui_row(row: &RepoWorkMapClosureRow) -> String { ) } +fn repo_work_map_acceptance_rows( + repo_work_map_entries: &[EpiphanyCultMeshRepoWorkMapEntry], +) -> (Vec, Vec) { + let rows = repo_work_map_entries + .iter() + .map(repo_work_map_acceptance_row) + .collect::>(); + let tui_rows = rows + .iter() + .map(repo_work_map_acceptance_tui_row) + .collect::>(); + (rows, tui_rows) +} + +fn repo_work_map_acceptance_row( + entry: &EpiphanyCultMeshRepoWorkMapEntry, +) -> RepoWorkMapAcceptanceRow { + let soul_closed = !entry.soul_verdict_receipt_id.trim().is_empty(); + let modeling_closed = !entry.modeling_summary.trim().is_empty(); + let mind_committed = !entry.mind_gateway_review_id.trim().is_empty() + && !entry.mind_state_commit_receipt_id.trim().is_empty() + && entry.durable_state_admitted; + let bifrost_gate_named = !entry.publication_gate.trim().is_empty() + && entry.publication_gate != "none" + && entry.publication_gate != "missing"; + let acceptance_status = + if soul_closed && modeling_closed && mind_committed && bifrost_gate_named { + "accepted-awaiting-publication-gate" + } else { + "incomplete-acceptance" + }; + RepoWorkMapAcceptanceRow { + item: entry.item.clone(), + branch: entry.branch.clone(), + safe_action_family: entry.safe_action_family.clone(), + acceptance_status: acceptance_status.to_string(), + soul_closed, + modeling_closed, + mind_committed, + durable_state_admitted: entry.durable_state_admitted, + bifrost_gate_named, + soul_verdict_receipt_id: entry.soul_verdict_receipt_id.clone(), + modeling_summary: entry.modeling_summary.clone(), + mind_gateway_review_id: entry.mind_gateway_review_id.clone(), + mind_state_commit_receipt_id: entry.mind_state_commit_receipt_id.clone(), + publication_gate: entry.publication_gate.clone(), + sight_only: true, + private_state_exposed: entry.private_state_exposed, + } +} + +fn repo_work_map_acceptance_tui_row(row: &RepoWorkMapAcceptanceRow) -> String { + format!( + "REPO-WORK-MAP-ACCEPTANCE | item={} | family={} | branch={} | status={} | soulClosed={} | modelingClosed={} | mindCommitted={} | durableAdmitted={} | publicationGate={} | bifrostGateNamed={} | soul={} | mindReview={} | mindCommit={} | summary={} | sightOnly={} | private={}", + row.item, + row.safe_action_family, + row.branch, + row.acceptance_status, + row.soul_closed, + row.modeling_closed, + row.mind_committed, + row.durable_state_admitted, + row.publication_gate, + row.bifrost_gate_named, + row.soul_verdict_receipt_id, + row.mind_gateway_review_id, + row.mind_state_commit_receipt_id, + compact_tui_text(&row.modeling_summary, 120), + row.sight_only, + row.private_state_exposed + ) +} + fn repo_work_peer_tui_rows(rows: &[RepoWorkOverviewRow]) -> Vec { rows.iter() .map(|row| { @@ -6741,6 +6849,8 @@ fn load_swarm_overview_report(args: &Args) -> Result { repo_work_map_gate_lens_rows(&repo_work_map_entries); let (repo_work_map_closure_rows, repo_work_map_closure_tui_rows) = repo_work_map_closure_rows(&repo_work_map_entries); + let (repo_work_map_acceptance_rows, repo_work_map_acceptance_tui_rows) = + repo_work_map_acceptance_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 (idunn_deployment_receipt_rows, idunn_deployment_receipt_tui_rows) = @@ -6791,6 +6901,9 @@ fn load_swarm_overview_report(args: &Args) -> Result { || repo_work_map_closure_rows .iter() .any(|row| row.private_state_exposed) + || repo_work_map_acceptance_rows + .iter() + .any(|row| row.private_state_exposed) || repo_work_public_proofs .iter() .any(|proof| proof.private_state_exposed) @@ -6863,6 +6976,8 @@ fn load_swarm_overview_report(args: &Args) -> Result { repo_work_map_gate_lens_tui_rows, repo_work_map_closure_rows, repo_work_map_closure_tui_rows, + repo_work_map_acceptance_rows, + repo_work_map_acceptance_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 febd6688..f220b046 100644 --- a/notes/epiphany-repo-swarm-mvp-contract.md +++ b/notes/epiphany-repo-swarm-mvp-contract.md @@ -1409,6 +1409,24 @@ refused. This is closure readback only, not publication authority, merge authority, service lifecycle authority, deployment authority, cross-repo authority, or Mind admission authority. +The family-friendly acceptance lens names the closure state in one operator-safe +row: +`.epiphany-smoke\repo-close-mind-adoption-guard-20260621-082322` proves Gjallar +now derives `repoWorkMapAcceptanceRows` and `REPO-WORK-MAP-ACCEPTANCE` TUI rows +from Mind-admitted map entries. The proof row reports +`status=accepted-awaiting-publication-gate`, `soulClosed=true`, +`modelingClosed=true`, `mindCommitted=true`, `durableAdmitted=true`, +`publicationGate=Bifrost`, `bifrostGateNamed=true`, `sightOnly=true`, and +`privateStateExposed=false`; the smoke summary reports +`gjallarRepoWorkMapAcceptanceCount=1` and +`gjallarRepoWorkMapAcceptanceStatus=accepted-awaiting-publication-gate` after +counterfeit Mind adoption is still refused. Wrapper proof +`local-20260621-092458-019-7ba89841` pointed `gjallar` at the repo-local Verse +and printed the same compact acceptance row. This is acceptance sight only: +Bifrost still owns publication/upstream gates, and Gjallar does not schedule, +publish, merge, deploy, keep daemons alive, cross repo boundaries, or admit Mind +state. + The wrapper mouth now forwards those Rust-owned repo-work map rows instead of making agents parse JSON artifacts. `tools/epiphany_local_run.ps1` accepts `-LocalVerseStore` and `-LocalVerseRuntimeId`, keeps operator run diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index f49e33fb..6ed99a53 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -162,6 +162,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-20: Gjallar repo-work map sight now includes next-publication-gate lenses. `epiphany-verse-query gjallar`, swarm overview, and swarm triage expose `repoWorkMapGateLensRows` plus `REPO-WORK-MAP-GATE` rows derived from the same Mind-admitted local Verse map entries, grouping accepted consequences by publication gate and naming the owning gate organ. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-233353` proves accepted `repo.markdown_planning_note` work reports `gate=Bifrost`, `owner=Bifrost`, latest item/commit/Mind commit receipt, `sightOnly=true`, `publicationAuthorized=false`, and `privateStateExposed=false`. This is sight only; Bifrost still owns publication/credit/upstream review and Gjallar does not schedule, publish, merge, deploy, keep daemons alive, or admit Mind state. - 2026-06-20: Gjallar repo-work map sight now includes per-entry semantic readback rows. `epiphany-verse-query gjallar`, swarm overview, and swarm triage expose `repoWorkMapSemanticRows` plus `REPO-WORK-MAP-SEMANTIC` rows derived from Mind-admitted local Verse map entries, combining durable modeling summary, safe family, stage owner, publication gate owner, latest commit, and Mind commit receipt for each accepted item. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-234131` proves accepted `repo.markdown_planning_note` work reports `stage=imagination-planning`, `stageOwner=Imagination`, `gateOwner=Bifrost`, the durable modeling summary, `sightOnly=true`, `publicationAuthorized=false`, and `privateStateExposed=false` while counterfeit Mind adoption is still refused. This is compact meaning readback only; Gjallar still does not schedule, publish, merge, deploy, keep daemons alive, or admit Mind state. - 2026-06-21: Gjallar repo-work map sight now includes per-entry closure readback rows. `epiphany-verse-query gjallar`, swarm overview, swarm triage, and the local wrapper summaries expose `repoWorkMapClosureRows` plus `REPO-WORK-MAP-CLOSURE` rows derived from Mind-admitted local Verse map entries, combining safe family, branch, commit, changed-path count, Soul verdict receipt id, Mind gateway review id, Mind state commit id, durable admission, Bifrost publication gate, and explicit denials for publication, merge, service lifecycle, deployment execution, and cross-repo mutation. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260621-075522` proves counterfeit Mind adoption is still refused, real close passes, `gjallarRepoWorkMapClosureCount=1`, and `privateStateExposed=false`; wrapper proof `local-20260621-085736-645-72c217a6` pointed `gjallar` at that repo-local Verse and printed the compact closure row with `publicationAuth=false`, `mergeAuth=false`, `serviceAuth=false`, `deploymentAuth=false`, `crossRepoAuth=false`, `sightOnly=true`, and `private=false`. +- 2026-06-21: Gjallar repo-work map sight now includes a family-friendly acceptance lens. `epiphany-verse-query gjallar`, swarm overview, swarm triage, and the local wrapper summaries expose `repoWorkMapAcceptanceRows` plus `REPO-WORK-MAP-ACCEPTANCE` rows derived from Mind-admitted local Verse map entries, reporting Soul closure, Modeling closure, Mind gateway review, Mind state commit, durable map admission, and named Bifrost publication gate readiness. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260621-082322` proves counterfeit Mind adoption is still refused, real close passes, `gjallarRepoWorkMapAcceptanceCount=1`, `gjallarRepoWorkMapAcceptanceStatus=accepted-awaiting-publication-gate`, and `privateStateExposed=false`; wrapper proof `local-20260621-092458-019-7ba89841` pointed `gjallar` at that repo-local Verse and printed the compact acceptance row with `soulClosed=true`, `modelingClosed=true`, `mindCommitted=true`, `durableAdmitted=true`, `publicationGate=Bifrost`, `bifrostGateNamed=true`, `sightOnly=true`, and `private=false`. This is sight only; Bifrost still owns publication/upstream gates and Gjallar gains no scheduling, publication, merge, deployment, service lifecycle, cross-repo mutation, or Mind admission authority. - 2026-06-21: The local wrapper mouth now forwards Rust-owned repo-work map rows for `gjallar` and `swarm-triage` from an explicit repo-local Verse target. `tools/epiphany_local_run.ps1` accepts `-LocalVerseStore` and `-LocalVerseRuntimeId`; operator run intent/receipt documents still write to the operator local Verse, while the readback modes target the requested store/runtime. Live wrapper proofs `local-20260621-011151-541-70056545` and `local-20260621-011207-755-d65e5c7e` pointed at `.epiphany-smoke\repo-planning-brief-family-20260620-235939\repo-body\.epiphany\local-verse.ccmp` with runtime `repo-planning-brief-family-smoke` and printed actual `repoWorkMapRows`, `repoWorkSemanticRows`, family/path/branch/stage/gate lens rows, and `privateStateExposed=false`. Earlier wrapper proofs that rendered `none` were aimed at the wrong operator store/runtime; PowerShell only lowers existing Rust TUI arrays and does not reinterpret repo-work truth or gain scheduler/publication/Mind/Idunn authority. - 2026-06-21: Idunn-hosted repo-work queue-run lifecycle now has bounded launch proof. `tools/epiphany_local_run.ps1 -Mode repo-work-service-launch` reuses the `epiphany-repo-work-queue-runner` service id and launches the exact `epiphany-work queue-run --workspace --local-verse-store \.epiphany\local-verse.ccmp --runtime-id --max-items ` command through `epiphany-daemon-supervisor service-launch --wait-child`; it writes an Idunn service lifecycle receipt and does not install a Windows service, elevate, publish, merge, cross repos, or expose private state. Native smoke `.epiphany-smoke\repo-work-service-lifecycle-20260621-002707` proves plan/runbook/launch with launch exit code `0`, runbook receipt-directory readback before launch, launch readback after launch, `mutatesServiceManager=false`, `launchesService=true`, `waitChild=true`, and `privateStateExposed=false`. Wrapper proof `local-20260621-012741-653-dd4fdae2` prints `status=completed`, `exitCode=0`, `owner=Idunn`, `hostedBody=repo-work`, and `serviceManagerMutation=false`. - 2026-06-21: Idunn-hosted repo-work queue-run lifecycle now has audit/readiness closure. `epiphany-daemon-supervisor repo-work-service-audit` reads the typed service lifecycle receipts for `epiphany-repo-work-queue-runner`, requires planned install-plan, written local runbook artifact, completed launch with exit code `0`, and no private-state exposure, then writes a `repo-work-service-audit` receipt. Native smoke `.epiphany-smoke\repo-work-service-lifecycle-20260621-004202` proves plan/runbook/launch/audit with `auditStatus=complete`, `auditRunbookArtifactStatus=present`, `auditLaunchExitCode=0`, `mutatesServiceManager=false`, `requiresElevatedAuthority=false`, and `privateStateExposed=false`. Wrapper proofs `local-20260621-014302-362-31bbef47`, `local-20260621-014337-108-cbd99615`, `local-20260621-014413-125-09e183c5`, and `local-20260621-014558-197-f6951806` prove plan/runbook/launch/audit ergonomics; the final audit summary reports `missing=none`, `failed=none`, and `nextSafeMove=continue repo-swarm MVP planner/interpreter hardening`. Remaining Idunn service work is optional elevated install/start execution under explicit operator authority, not Self scheduling. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 89127fbcff8a4900ff3956de6650355beb4065a4..f0d9fcb216699f2d01086a1ea406e0a028fe215b 100644 GIT binary patch delta 405 zcmW+yu}T9$6m(+_3tI_-7Av-{cUd)FQV1~w3yBFaB3KBU+m~czvwQCDDJj)L1WUse z+F00%U?Kj1t+kb(qL;uM9s~1chWC^fULFf?i)fyfDs=1QYsS03eqTlB2#K3X2WpbNdeWNAxlU7GwAz)Div12L%EJ0b!!H5g6 zxLt2G$#Jv2Pa4%0sn%-sR;PMUtEazRFQ~6!1F<$vs6IZ_iS!$qgUp!U5Q_UeF{~@W z-xWQht;@uW3kB9$qjK?xkqOTTcH@y_KCJ z2|~I-DQ1e}OT*$A43;`#l1!c!lxU_X)6K1r1jRDh?y|5PZWeLOtOcH;qgnh9`E7>^ delta 53 zcmZ2FTWrpBu?-T8+=fP0Mn+M`7+AY1H!Cw1GBRc~Pi1PK%ESo7AetG7S+-AQVrB0H E0KDT5&Hw-a diff --git a/state/map.yaml b/state/map.yaml index 8ed1cfc2..5001ed30 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -99,6 +99,7 @@ active_subgoals: - 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 now derives per-entry closure readback rows from the same Mind-admitted local Verse map rows. `repoWorkMapClosureRows` / `REPO-WORK-MAP-CLOSURE` combine safe family, branch, commit, changed-path count, Soul verdict receipt id, Mind gateway review id, Mind state commit id, durable admission, Bifrost publication gate, and explicit denials for publication, merge, service lifecycle, deployment execution, and cross-repo mutation while preserving `sightOnly=true` and `privateStateExposed=false`. Proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260621-075522` passed with `gjallarRepoWorkMapClosureCount=1` after counterfeit Mind adoption was still refused; wrapper proof `local-20260621-085736-645-72c217a6` printed the same closure row from an explicit repo-local Verse target. + - Gjallar now derives a family-friendly acceptance lens from the same Mind-admitted local Verse map rows. `repoWorkMapAcceptanceRows` / `REPO-WORK-MAP-ACCEPTANCE` report whether each accepted repo-work item has Soul closure, Modeling closure, Mind gateway review, Mind state commit, durable map admission, and a named Bifrost publication gate; completed rows show `accepted-awaiting-publication-gate` while preserving `sightOnly=true` and `privateStateExposed=false`. Proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260621-082322` passed with `gjallarRepoWorkMapAcceptanceCount=1` and `gjallarRepoWorkMapAcceptanceStatus=accepted-awaiting-publication-gate` after counterfeit Mind adoption was still refused; wrapper proof `local-20260621-092458-019-7ba89841` printed the compact acceptance row from the repo-local Verse target. This is acceptance sight only; Bifrost still owns publication/upstream gates and Gjallar gains no scheduling, publication, merge, deployment, service lifecycle, cross-repo mutation, or Mind admission authority. - The local wrapper now has an explicit repo-local Verse readback target for Gjallar/swarm-triage. `tools/epiphany_local_run.ps1` accepts `-LocalVerseStore` and `-LocalVerseRuntimeId`; operator intent/receipt documents still write to the operator store, while `gjallar` and `swarm-triage` read compact repo-work map rows from the requested store/runtime. Wrapper proofs `local-20260621-011151-541-70056545` and `local-20260621-011207-755-d65e5c7e` aimed at `.epiphany-smoke\repo-planning-brief-family-20260620-235939\repo-body\.epiphany\local-verse.ccmp` with runtime `repo-planning-brief-family-smoke` and printed real `REPO-WORK-MAP`, `REPO-WORK-MAP-SEMANTIC`, family/path/branch/stage/gate rows with `privateStateExposed=false`. This is sight targeting only; the wrapper does not register repo-work schemas, reinterpret rows, or gain operator, Mind, Bifrost, Idunn, scheduler, publication, deployment, or service 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-work overview` now also emits `epiphany.repo_work_intake_consensus_readback.v0` plus a compact `CONSENSUS` TUI row from the accept/plan receipt chain, so agents can see Persona/public feedback ids, Imagination consensus receipt route, public/candidate ref counts, model-authored safe family, and authority denials without opening private payloads. `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`, wrapper artifact `local-20260620-014627-174-aada0241`, and consensus readback smoke `.epiphany-smoke\repo-consensus-brief-family-20260621-005433` show queue sight, public Eve lowering, direct queue-run advancement, wrapper dry-run, and Persona-to-Imagination consensus readback 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. diff --git a/tools/epiphany_local_run.ps1 b/tools/epiphany_local_run.ps1 index 3df1fc77..5a86e6e7 100644 --- a/tools/epiphany_local_run.ps1 +++ b/tools/epiphany_local_run.ps1 @@ -2503,6 +2503,7 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) { $repoWorkStageLensRows = Format-TuiRows $result.repoWorkMapStageLensTuiRows $repoWorkGateLensRows = Format-TuiRows $result.repoWorkMapGateLensTuiRows $repoWorkClosureRows = Format-TuiRows $result.repoWorkMapClosureTuiRows + $repoWorkAcceptanceRows = Format-TuiRows $result.repoWorkMapAcceptanceTuiRows $repoWorkOverviewRows = Format-TuiRows $result.repoWorkOverviewTuiRows $repoWorkPublicProofRows = Format-TuiRows $result.repoWorkPublicProofTuiRows $swarmOnlineTool = "none" @@ -2513,7 +2514,7 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) { 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, repoWorkOverviewRows=$repoWorkOverviewRows, repoWorkPublicProofRows=$repoWorkPublicProofRows, toolHostAttention=$toolHostAttention, toolAttentionRows=$toolAttentionRows, serviceLifecycleAttention=$serviceLifecycleAttention, serviceAttentionRows=$serviceAttentionRows, serviceExecutionFailedChecks=$serviceExecutionFailedChecks, serviceFailedCheckRows=$serviceFailedCheckRows, privateStateExposed=$($result.privateStateExposed)" + 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, 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" @@ -2697,9 +2698,10 @@ if ($resultPath -ne "" -and (Test-Path -LiteralPath $resultPath)) { $repoWorkStageLensRows = Format-TuiRows $result.repoWorkMapStageLensTuiRows $repoWorkGateLensRows = Format-TuiRows $result.repoWorkMapGateLensTuiRows $repoWorkClosureRows = Format-TuiRows $result.repoWorkMapClosureTuiRows + $repoWorkAcceptanceRows = Format-TuiRows $result.repoWorkMapAcceptanceTuiRows $repoWorkOverviewRows = Format-TuiRows $result.repoWorkOverviewTuiRows $repoWorkPublicProofRows = Format-TuiRows $result.repoWorkPublicProofTuiRows - Write-Host "Swarm triage: status=$($result.status), overview=$($result.overviewStatus), liveness=$($result.livenessStatus), recovery=$($result.recoveryStatus), clusters=$($result.clusterCount), privateVerses=$($result.privateVerseCount), recommended=$($result.recommendedWrapperMode), serviceRecommended=$($result.serviceLifecycleRecommendedWrapperMode), actionQueue=$actionQueue, actionRows=$actionRows, attention=$attention, daemonRows=$daemonRows, repoWorkMapRows=$repoWorkMapRows, repoWorkSemanticRows=$repoWorkSemanticRows, repoWorkFamilyLensRows=$repoWorkFamilyLensRows, repoWorkPathLensRows=$repoWorkPathLensRows, repoWorkBranchLensRows=$repoWorkBranchLensRows, repoWorkStageLensRows=$repoWorkStageLensRows, repoWorkGateLensRows=$repoWorkGateLensRows, repoWorkClosureRows=$repoWorkClosureRows, repoWorkOverviewRows=$repoWorkOverviewRows, repoWorkPublicProofRows=$repoWorkPublicProofRows, toolHostAttention=$toolHostAttention, toolAttentionRows=$toolAttentionRows, serviceLifecycleAttention=$serviceLifecycleAttention, serviceAttentionRows=$serviceAttentionRows, serviceExecutionFailedChecks=$serviceExecutionFailedChecks, serviceFailedCheckRows=$serviceFailedCheckRows, poked=$($result.pokedDaemonCount), privateStateExposed=$($result.privateStateExposed)" + Write-Host "Swarm triage: status=$($result.status), overview=$($result.overviewStatus), liveness=$($result.livenessStatus), recovery=$($result.recoveryStatus), clusters=$($result.clusterCount), privateVerses=$($result.privateVerseCount), recommended=$($result.recommendedWrapperMode), serviceRecommended=$($result.serviceLifecycleRecommendedWrapperMode), actionQueue=$actionQueue, actionRows=$actionRows, attention=$attention, daemonRows=$daemonRows, repoWorkMapRows=$repoWorkMapRows, repoWorkSemanticRows=$repoWorkSemanticRows, repoWorkFamilyLensRows=$repoWorkFamilyLensRows, repoWorkPathLensRows=$repoWorkPathLensRows, repoWorkBranchLensRows=$repoWorkBranchLensRows, repoWorkStageLensRows=$repoWorkStageLensRows, repoWorkGateLensRows=$repoWorkGateLensRows, repoWorkClosureRows=$repoWorkClosureRows, repoWorkAcceptanceRows=$repoWorkAcceptanceRows, repoWorkOverviewRows=$repoWorkOverviewRows, repoWorkPublicProofRows=$repoWorkPublicProofRows, toolHostAttention=$toolHostAttention, toolAttentionRows=$toolAttentionRows, serviceLifecycleAttention=$serviceLifecycleAttention, serviceAttentionRows=$serviceAttentionRows, serviceExecutionFailedChecks=$serviceExecutionFailedChecks, serviceFailedCheckRows=$serviceFailedCheckRows, poked=$($result.pokedDaemonCount), privateStateExposed=$($result.privateStateExposed)" } elseif ($Mode -eq "service-runbook") { $artifactSha256 = Get-LocalArtifactSha256 $result.runbookPath Write-Host "Service runbook: service=$($result.serviceId), receipt=$($result.receiptId), artifactSha256=$artifactSha256, followUp=tools/epiphany_local_run.ps1 -Mode service-launch, aftercare=tools/epiphany_local_run.ps1 -Mode service-status, path=$($result.runbookPath)"