From 85197fe86d0c87bd0fe9f3884d054defc2113e79 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sun, 21 Jun 2026 13:13:26 +0100 Subject: [PATCH] Account readiness review in Bifrost ledger --- .../bin/epiphany-repo-work-readiness-smoke.rs | 83 ++++++++++++++++ epiphany-core/src/bin/epiphany-verse-query.rs | 92 +++++++++++++++++- notes/epiphany-repo-swarm-mvp-contract.md | 20 +++- notes/fresh-workspace-handoff.md | 3 +- state/ledgers.msgpack | Bin 372507 -> 373151 bytes state/map.yaml | 6 +- tools/epiphany_local_run.ps1 | 2 +- 7 files changed, 196 insertions(+), 10 deletions(-) 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 c4be225d..1790fc7b 100644 --- a/epiphany-core/src/bin/epiphany-repo-work-readiness-smoke.rs +++ b/epiphany-core/src/bin/epiphany-repo-work-readiness-smoke.rs @@ -562,6 +562,33 @@ fn run_smoke(args: Args) -> Result { )?; require_tui_row_contains(&receipt_directory, &["tuiRows"], "artifact=present")?; require_bool(&receipt_directory, &["privateStateExposed"], false)?; + let bifrost_ledger = cargo_json( + &manifest, + "epiphany-verse-query", + &[ + "bifrost-ledger", + "--store", + path_str(&local_verse)?, + "--runtime-id", + "repo-work-readiness-smoke", + ], + &root, + )?; + require_bifrost_accounting_row( + &bifrost_ledger, + "repo-work-readiness-review", + "closed", + "repo-work-readiness-review-repo-work-readiness", + 4, + 1, + )?; + require_tui_row_contains( + &bifrost_ledger, + &["accountingTuiRows"], + "BIFROST-ACCOUNTING | repo-work-readiness-review", + )?; + require_tui_row_contains(&bifrost_ledger, &["accountingTuiRows"], "status=closed")?; + require_bool(&bifrost_ledger, &["privateStateExposed"], false)?; let summary = json!({ "schemaVersion": "epiphany.repo_work_readiness_smoke.v0", @@ -586,6 +613,8 @@ fn run_smoke(args: Args) -> Result { "gjallarLatestRepoWorkReadinessReview": gjallar["latestRepoWorkReadinessReview"], "receiptDirectoryRowCount": receipt_directory["rowCount"], "receiptDirectoryReadinessReviewRow": receipt_directory_row_value(&receipt_directory, "repo-work-readiness-review")?, + "bifrostLedgerAccountingRowCount": bifrost_ledger["accountingRowCount"], + "bifrostReadinessReviewAccountingRow": bifrost_accounting_row_value(&bifrost_ledger, "repo-work-readiness-review")?, "sightOnly": readiness["authority"]["sightOnly"], "readinessApprovalAuthorized": readiness["authority"]["readinessApprovalAuthorized"], "publicationAuthorized": readiness["authority"]["publicationAuthorized"], @@ -855,6 +884,60 @@ fn require_receipt_directory_row( } } +fn bifrost_accounting_row_value<'a>(value: &'a Value, lane: &str) -> Result<&'a Value> { + value + .get("accountingRows") + .and_then(Value::as_array) + .and_then(|rows| { + rows.iter() + .find(|row| row.get("lane").and_then(Value::as_str) == Some(lane)) + }) + .ok_or_else(|| anyhow!("missing Bifrost accounting row {lane:?}")) +} + +fn require_bifrost_accounting_row( + value: &Value, + lane: &str, + status: &str, + latest_receipt_id: &str, + review_receipt_count: u64, + public_artifact_count: u64, +) -> Result<()> { + let row = bifrost_accounting_row_value(value, lane)?; + let actual_status = row + .get("status") + .and_then(Value::as_str) + .unwrap_or(""); + let actual_latest_receipt_id = row + .get("latestReceiptId") + .and_then(Value::as_str) + .unwrap_or(""); + let actual_review_receipt_count = row + .get("reviewReceiptCount") + .and_then(Value::as_u64) + .unwrap_or(0); + let actual_public_artifact_count = row + .get("publicArtifactCount") + .and_then(Value::as_u64) + .unwrap_or(0); + let actual_private = row + .get("privateStateExposed") + .and_then(Value::as_bool) + .unwrap_or(true); + if actual_status == status + && actual_latest_receipt_id == latest_receipt_id + && actual_review_receipt_count == review_receipt_count + && actual_public_artifact_count == public_artifact_count + && !actual_private + { + Ok(()) + } else { + Err(anyhow!( + "Bifrost accounting row {lane:?} mismatch: status={actual_status:?}, latestReceiptId={actual_latest_receipt_id:?}, reviewReceiptCount={actual_review_receipt_count}, publicArtifactCount={actual_public_artifact_count}, privateStateExposed={actual_private}" + )) + } +} + fn take_path( args: &mut std::iter::Peekable>, flag: &str, diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs index 8aea09e4..8b625dfc 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -1236,6 +1236,7 @@ fn run_cli() -> Result<()> { "latestBifrostPublicationReceipt": report.latest_publication_receipt_id, "latestBifrostGithubReceipt": report.latest_github_receipt_id, "latestBifrostPublicProofPublicationReceipt": report.latest_public_proof_publication_receipt_id, + "latestRepoWorkReadinessReview": report.latest_readiness_review_id, "latestBifrostCollaborationFeedback": report.latest_feedback_id, "latestImaginationConsensusReceipt": report.latest_consensus_receipt_id, "accountingTuiRows": report.accounting_tui_rows, @@ -2714,7 +2715,7 @@ fn run_cli() -> Result<()> { if bifrost_ledger_report.status != "ok" || bifrost_ledger_report.publication_chain_count != 3 || bifrost_ledger_report.collaboration_chain_count != 2 - || bifrost_ledger_report.accounting_rows.len() != 3 + || bifrost_ledger_report.accounting_rows.len() != 4 || bifrost_ledger_report.closed_accounting_row_count != 2 || bifrost_ledger_report.attention_accounting_row_count != 0 || bifrost_ledger_report.rows.len() != 5 @@ -2749,6 +2750,13 @@ fn run_cli() -> Result<()> { && row.contains("proof=missing") && row.contains("private=false") }) + || !bifrost_ledger_report.accounting_tui_rows.iter().any(|row| { + row.contains("BIFROST-ACCOUNTING | repo-work-readiness-review") + && row.contains("status=missing") + && row.contains("review=0") + && row.contains("approval=missing") + && row.contains("private=false") + }) || !bifrost_ledger_report.accounting_tui_rows.iter().any(|row| { row.contains("BIFROST-ACCOUNTING | collaboration-consensus") && row.contains("status=closed") @@ -4928,6 +4936,7 @@ struct BifrostLedgerReport { latest_publication_receipt_id: Option, latest_github_receipt_id: Option, latest_public_proof_publication_receipt_id: Option, + latest_readiness_review_id: Option, latest_feedback_id: Option, latest_consensus_receipt_id: Option, private_state_exposed: bool, @@ -8524,6 +8533,10 @@ fn load_bifrost_ledger_report(args: &Args) -> Result { &args.store, args.runtime_id.clone(), )?; + let latest_readiness_review = load_latest_epiphany_cultmesh_repo_work_readiness_review( + &args.store, + args.runtime_id.clone(), + )?; let latest_feedback = load_latest_epiphany_cultmesh_bifrost_collaboration_feedback( &args.store, args.runtime_id.clone(), @@ -8537,6 +8550,7 @@ fn load_bifrost_ledger_report(args: &Args) -> Result { latest_publication.as_ref(), latest_github.as_ref(), latest_public_proof_publication.as_ref(), + latest_readiness_review.as_ref(), latest_feedback.as_ref(), latest_consensus.as_ref(), )) @@ -8549,6 +8563,7 @@ fn bifrost_ledger_report( latest_public_proof_publication: Option< &EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry, >, + latest_readiness_review: Option<&EpiphanyCultMeshRepoWorkReadinessReviewEntry>, latest_feedback: Option<&EpiphanyCultMeshBifrostCollaborationFeedbackEntry>, latest_consensus: Option<&EpiphanyCultMeshImaginationConsensusReceiptEntry>, ) -> BifrostLedgerReport { @@ -8674,6 +8689,7 @@ fn bifrost_ledger_report( latest_publication, latest_github, latest_public_proof_publication, + latest_readiness_review, latest_feedback, latest_consensus, ); @@ -8685,7 +8701,8 @@ fn bifrost_ledger_report( .iter() .filter(|row| row.status == "attention" || row.private_state_exposed) .count(); - let private_state_exposed = rows.iter().any(|row| row.private_state_exposed); + let private_state_exposed = rows.iter().any(|row| row.private_state_exposed) + || accounting_rows.iter().any(|row| row.private_state_exposed); let status = if rows.is_empty() { "empty" } else if private_state_exposed { @@ -8711,6 +8728,7 @@ fn bifrost_ledger_report( latest_github_receipt_id: latest_github.map(|receipt| receipt.receipt_id.clone()), latest_public_proof_publication_receipt_id: latest_public_proof_publication .map(|receipt| receipt.receipt_id.clone()), + latest_readiness_review_id: latest_readiness_review.map(|review| review.review_id.clone()), latest_feedback_id: latest_feedback.map(|feedback| feedback.feedback_id.clone()), latest_consensus_receipt_id: latest_consensus.map(|receipt| receipt.receipt_id.clone()), private_state_exposed, @@ -8746,6 +8764,7 @@ fn bifrost_accounting_rows( latest_public_proof_publication: Option< &EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry, >, + latest_readiness_review: Option<&EpiphanyCultMeshRepoWorkReadinessReviewEntry>, latest_feedback: Option<&EpiphanyCultMeshBifrostCollaborationFeedbackEntry>, latest_consensus: Option<&EpiphanyCultMeshImaginationConsensusReceiptEntry>, ) -> (Vec, Vec) { @@ -8862,6 +8881,75 @@ fn bifrost_accounting_rows( }, ); + let readiness_private = latest_readiness_review + .map(|review| review.private_state_exposed) + .unwrap_or(false); + let readiness_review_count = latest_readiness_review + .map(|review| { + [ + &review.maintainer_review_receipt, + &review.soul_review_receipt, + &review.mind_review_receipt, + &review.bifrost_review_receipt, + ] + .iter() + .filter(|receipt| !receipt.trim().is_empty() && receipt.as_str() != "none") + .count() + }) + .unwrap_or(0); + let readiness_artifact_present = latest_readiness_review + .map(|review| operator_artifact_status(&review.readiness_review_receipt_ref) == "present") + .unwrap_or(false); + let readiness_closed = latest_readiness_review + .map(|review| { + review.status == "readiness-approved" + && review.missing_required_count == 0 + && review.readiness_approval_authorized + && !review.durable_state_commit_authorized + && !review.publication_authorized + && !review.merge_authorized + && !review.upstream_sync_authorized + && !review.deployment_authority + && !review.service_lifecycle_authority + && !review.hands_action_authorized + && readiness_review_count == 4 + && readiness_artifact_present + && !readiness_private + }) + .unwrap_or(false); + push_bifrost_accounting_row( + &mut rows, + &mut tui_rows, + BifrostAccountingRow { + lane: "repo-work-readiness-review".to_string(), + owner: "Maintainer/Soul/Mind/Bifrost".to_string(), + status: bifrost_accounting_status( + readiness_closed, + latest_readiness_review.is_some(), + readiness_private, + ), + closure: format!( + "review={} approval={} artifact={}", + readiness_review_count, + latest_readiness_review + .map(|review| review.status.as_str()) + .unwrap_or("missing"), + present_word(readiness_artifact_present) + ), + ledger_entry_id: "none".to_string(), + latest_receipt_id: latest_readiness_review + .map(|review| review.review_id.clone()) + .unwrap_or_else(|| "none".to_string()), + public_ref: latest_readiness_review + .map(|review| review.readiness_review_receipt_ref.clone()) + .unwrap_or_else(|| "none".to_string()), + review_receipt_count: readiness_review_count, + credit_receipt_count: 0, + public_artifact_count: usize::from(readiness_artifact_present), + private_state_exposed: readiness_private, + }, + ); + let collaboration_private = latest_feedback .map(|feedback| feedback.private_state_included) .unwrap_or(false) diff --git a/notes/epiphany-repo-swarm-mvp-contract.md b/notes/epiphany-repo-swarm-mvp-contract.md index 1c5d8df9..74997018 100644 --- a/notes/epiphany-repo-swarm-mvp-contract.md +++ b/notes/epiphany-repo-swarm-mvp-contract.md @@ -1727,13 +1727,27 @@ published `repo-work-public-proof-checklist-request` to Bifrost ledger readback now also emits derived external-work accounting rows without creating a rival ledger. `epiphany-verse-query bifrost-ledger` returns `accountingRows` and `accountingTuiRows` for `body-change-publication`, -`public-proof-publication`, and `collaboration-consensus`, carrying closure -status, ledger/receipt/public refs, review and credit receipt counts, artifact -count, and the private-state seal. Wrapper proof +`public-proof-publication`, `repo-work-readiness-review`, and +`collaboration-consensus`, carrying closure status, ledger/receipt/public refs, +review and credit receipt counts, artifact count, and the private-state seal. +The readiness-review lane closes only when latest +`epiphany.cultmesh.repo_work_readiness_review.v0` has four Maintainer/Soul/Mind/ +Bifrost review refs, `status=readiness-approved`, zero missing required rows, a +present review artifact, readiness approval true, and durable-state, +publication, PR, merge, upstream-sync, deployment, service lifecycle, Hands, and +private-state authority all false. Wrapper proof `local-20260621-091019-297-aaf2ad07` reported `accountingRows=3`, `closedAccounting=2`, `attentionAccounting=0`, closed body-change and collaboration rows, a visible missing public-proof-publication row, and `privateStateExposed=False`. +Native proof `.epiphany-smoke\repo-work-readiness-20260621-120755` reported +`bifrostReadinessReviewAccountingRow.status=closed`, `reviewReceiptCount=4`, +`publicArtifactCount=1`, latest receipt +`repo-work-readiness-review-repo-work-readiness`, and `privateStateExposed=false`; +wrapper proof `local-20260621-131113-240-be2b19f2` printed the same closed +`BIFROST-ACCOUNTING | repo-work-readiness-review` row from the explicit +repo-local Verse target after the wrapper read path was corrected to use +`-LocalVerseStore` / `-LocalVerseRuntimeId`. Wrapper mode `tools/epiphany_local_run.ps1 -Mode bifrost-public-proof` now exposes the same Bifrost mouth for operators and agents. It reads the latest diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 5ea563ea..8fd1d605 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -57,7 +57,7 @@ remembers doctrine; the branch remembers the blade. - `epiphany-verse-query connect-eve` and `tools/epiphany_local_run.ps1 -Mode eve-connect` are the compact Odin-to-Eve connection receipt rite. The command now selects its target from the narrow Eve surface directory and verifies latest intent/receipt keys through narrow CultMesh loaders instead of serializing the full local Verse. The wrapper defaults to `epiphany.cluster.persona`, records intent `eve-connection-intent` plus receipt `eve-connection-receipt`, targets `eve://epiphany/persona`, and keeps `privateStateExposed=false`. Verified: direct temp proof and wrapper proof both returned `status=ok`. - `epiphany-verse-query collaboration-feedback` and `tools/epiphany_local_run.ps1 -Mode collaboration-feedback` are the compact public Persona feedback to Imagination consensus receipt rite. The command verifies latest feedback/consensus keys through narrow CultMesh loaders and emits follow-on commands for wrapper feedback, Eve connection, direct Bifrost publication, and wrapper Bifrost publication. It returns TUI rows for the feedback and Imagination consensus receipt with `owner=Persona->Imagination`, `owner=Imagination`, `public=`, candidate action refs, consensus packet ref, adoption gate, and `private=false`. The wrapper first records the prerequisite Eve connection receipt, then writes feedback `collaboration-feedback` plus consensus `imagination-consensus-receipt`; proof `local-20260618-224207-941-2ca01b41` printed both compact rows in `feedbackRows`, including Persona public discussion feedback routed to Imagination consensus discovery, with `privateStateExposed=False`. - `epiphany-verse-query bifrost-publication` and `tools/epiphany_local_run.ps1 -Mode bifrost-publication` are the compact non-mutating body-change publication proof rite. The command verifies latest Bifrost intent/publication/GitHub receipt keys through narrow CultMesh loaders and now emits follow-on commands for swarm overview, tool directory, and wrapper Bifrost publication readback. The wrapper supplies explicit proof defaults for target repo, changed path, verification/review receipts, credit subject, ledger id, Hands PR receipt id, and publication URL, then writes Bifrost intent, Bifrost publication receipt, and GitHub publication receipt with `privateStateExposed=false`. Verified: direct proof and wrapper proof both returned `status=ok`, and wrapper artifact `local-20260618-072118-704-3c5ae3da` carried the command hints. -- `epiphany-verse-query bifrost-ledger` and `tools/epiphany_local_run.ps1 -Mode bifrost-ledger` are the compact read-only Bifrost ledger sight rite. The command reads only the latest Bifrost body-change intent, Bifrost publication receipt, GitHub publication receipt, public-proof publication receipt, collaboration feedback, and Imagination consensus receipt through narrow CultMesh loaders. It returns raw ledger rows plus three derived `BIFROST-ACCOUNTING` rows for body-change publication, public-proof publication, and collaboration consensus, with closure status, ledger/receipt/public refs, review and credit receipt counts, artifact count, and private-state seal. Wrapper proof `local-20260621-091019-297-aaf2ad07` returned `accountingRows=3`, `closedAccounting=2`, `attentionAccounting=0`, closed body-change and collaboration rows, a visible missing public-proof-publication row, and `privateStateExposed=False`. +- `epiphany-verse-query bifrost-ledger` and `tools/epiphany_local_run.ps1 -Mode bifrost-ledger` are the compact read-only Bifrost ledger sight rite. The command reads only the latest Bifrost body-change intent, Bifrost publication receipt, GitHub publication receipt, public-proof publication receipt, repo-work readiness-review receipt, collaboration feedback, and Imagination consensus receipt through narrow CultMesh loaders. It returns raw ledger rows plus four derived `BIFROST-ACCOUNTING` rows for body-change publication, public-proof publication, repo-work readiness review, and collaboration consensus, with closure status, ledger/receipt/public refs, review and credit receipt counts, artifact count, and private-state seal. The readiness-review accounting row closes only with four Maintainer/Soul/Mind/Bifrost review refs, readiness approval, zero missing required rows, present review artifact, and no durable-state/publication/merge/sync/deployment/service/Hands/private authority. Native proof `.epiphany-smoke\repo-work-readiness-20260621-120755` reported the closed row with `reviewReceiptCount=4` and `publicArtifactCount=1`; wrapper proof `local-20260621-131113-240-be2b19f2` proved `bifrost-ledger` honors explicit repo-local Verse read targets. Older wrapper proof `local-20260621-091019-297-aaf2ad07` remains provenance for the first three accounting rows. - `epiphany-verse-query receipt-directory` and `tools/epiphany_local_run.ps1 -Mode receipt-directory` are the compact latest-witness directory over local Verse. The command indexes typed projections for operator run, daemon poke, daemon tool invocation, Eve connection, Bifrost publication, Imagination consensus, coordinator run, Hands gate, role review, work-loop, cluster service lifecycle, single-service lifecycle, cluster service execution runbook, single-service execution runbook, scheduler, Persona speech, and agent-state SoA without exposing raw payloads or private worker context. It treats sealed service lifecycle failure states such as `not-elevated`, `execution-refused-not-elevated`, and `incomplete` as operator attention instead of private-state exposure, routes cluster lifecycle wounds to `cluster-service-execution-audit`, preserves `service-execution-audit` for single-service receipts, and exposes the runbook witnesses as separate display-only `cluster-service-execution-runbook` and `service-execution-runbook` rows. The lifecycle projection now reads the typed receipt family, splits `cluster-service-lifecycle` from `service-lifecycle`, selects the latest attention receipt before falling back to latest overall, and renders service lifecycle routes as `service-id::action` so compact rows name the owning lifecycle action without exposing raw audit payloads. Compact TUI rows append `followUp=`, artifact status, and SHA-256; wrapper proof `local-20260618-205920-451-383b0da7` printed all seventeen rows in `receiptRows`, including missing Hands/role/work-loop gates, Bifrost/Imagination witnesses, scheduler follow-up, runbook hashes, and service lifecycle attention. `missingRowCount` remains as a compatibility alias for absent witnesses, not a fault signal. Attention routing is now Rust-owned too: JSON includes `attentionRouteRows` derived from the same predicate as `attentionRowCount`, and the wrapper prints that field instead of matching arbitrary status strings. Live proof `local-20260618-212134-758-c7c56240` showed the stale degraded Hands daemon-poke receipt remains an `OK` historical row while `attentionRoutes` names only the active cluster/single-service lifecycle wounds. Daemon-poke rows now also resolve historical receipt status against current daemon liveness: source smoke proves degraded remains degraded before heartbeat recovery and becomes `resolved` after ready status returns, and live wrapper proof `local-20260618-212649-563-48647018` printed the old Hands poke receipt as `OK | Self | daemon-poke | resolved`. - Public doctrine source `https://gamecult.org/Blog/purge-the-heretek-from-our-daemonic-swarm` sharpens the current swarm audit: Odin sees but must not own, Gjallar is Odin's herald for whole-Verse sight, Idunn-like ledgers must advance instead of freezing old wounds, and Bifrost is the ledger gate for cross-repo purification receipts rather than transcript archaeology. - `tools/epiphany_local_run.ps1` now stamps local run ids as `local-YYYYMMDD-HHMMSS-fff-` instead of second-resolution ids, so concurrent operator rites get separate artifact roots and run receipts. Verified: `collaboration-feedback` and `bifrost-publication` launched in parallel in the same second and completed as `local-20260618-064814-171-dc0b8dd9` and `local-20260618-064814-149-2946d675`. @@ -174,6 +174,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-21: Repo-work readiness now includes the family-friendly safe-family planning depth row, receipt-shaped Idunn/tool-directory validation, Bifrost/GitHub publication receipt-chain validation, and upstream-main sync receipt/ancestry validation. `epiphany-work readiness` inspects `closureReview.familyAssertions.safeFamilyPlanning` from the close receipt and satisfies `safe-family-planning` only for Soul-owned `epiphany.repo_work_safe_family_planning_readback.v0` over `repo.planning_brief` with all expected candidate families, requirements, gates, matrix groups, matrix controls, closure proofs, authority denials, and private-state seal intact. It satisfies `idunn-lifecycle` only from `epiphany.repo_work_service_audit.v0` with complete Idunn-owned repo-work service proof, zero missing/failed checks, no service-manager mutation, no elevation requirement, and private-state seal; satisfies `tool-directory` only from `epiphany.cultmesh.daemon_tool_directory.v0` with nonempty globally available receipt-gated daemon tools, ready hosts, invoke command hints, and private-state seal; satisfies `bifrost-publication` only when the local publish artifact matches latest repo-local CultMesh Bifrost body-change and GitHub publication receipts; and satisfies `upstream-main-sync` only when `epiphany.repo_work_sync_receipt.v0` proves nonempty merge/sync authority receipts, matching publish/Bifrost/GitHub/Hands ids, private-state seal, and live git ancestry that the published commit is contained by the named upstream ref. Native smoke `.epiphany-smoke\repo-work-readiness-20260621-110524` now runs the readiness proof through `repo-planning-brief` cargo, sealed Idunn/tool artifacts, real `epiphany-work publish`, disposable upstream-main merge proof, and `epiphany-work sync`, proving all sixteen rows satisfied with `status=ready`, `missingRequiredCount=0`, `syncStatus=upstream-main-synced`, and `upstreamMainSynced=true`. Wrapper proof `local-20260621-120641-609-72d32f64` prints the same no-gap row without granting readiness, scheduling, Hands, publication, deployment, service lifecycle, durable state commit, cross-body mutation, or private-state authority. - 2026-06-21: Repo-work readiness review/adoption now has an explicit typed gate. `epiphany-work readiness-review` consumes a ready `epiphany.repo_work_readiness_report.v0`, requires Maintainer, Soul, Mind, and Bifrost review receipt refs, refuses unless `missingRequiredCount=0` and every readiness row is satisfied, and writes `epiphany.repo_work_readiness_review_receipt.v0` with `status=readiness-approved`, `readinessApprovalAuthorized=true`, `readinessAdopted=true`, and durable-state/publication/PR/merge/upstream-sync/deployment/service/Hands/cross-body/private-state authority all false. Native smoke `.epiphany-smoke\repo-work-readiness-20260621-111411` proves the full ready chain plus review receipt with sixteen satisfied rows. Wrapper proof `local-20260621-121829-442-d011af09` proves `tools/epiphany_local_run.ps1 -Mode repo-work-readiness-review` prints the same approval boundary at the operator mouth. - 2026-06-21: Repo-work readiness review/adoption is now indexed by receipt-directory for public/operator proof. `epiphany-verse-query receipt-directory` adds the `repo-work-readiness-review` row from latest `epiphany.cultmesh.repo_work_readiness_review.v0`, with owner `Maintainer/Soul/Mind/Bifrost`, route to the readiness receipt, review artifact status/SHA-256, follow-up `tools/epiphany_local_run.ps1 -Mode repo-work-readiness-review`, and `privateStateExposed=false`. Native proof `.epiphany-smoke\repo-work-readiness-20260621-115547` reported row `latestId=repo-work-readiness-review-repo-work-readiness`, status `readiness-approved`, artifact SHA-256 `ba50bce3aa2af320a71977bde9d47108154665802dd527dd30bf8c4ab28bba5e`; wrapper proof `local-20260621-125756-748-03710f48` proved `receipt-directory` now honors explicit `-LocalVerseStore` / `-LocalVerseRuntimeId` for repo-local readback while operator receipts still write to the operator store. +- 2026-06-21: Bifrost ledger accounting now counts approved repo-work readiness review as a sealed external-work closure lane. `epiphany-verse-query bifrost-ledger` emits `BIFROST-ACCOUNTING | repo-work-readiness-review` from latest `epiphany.cultmesh.repo_work_readiness_review.v0`, closing only when approval status, four review refs, present artifact, zero missing rows, and all dangerous authority denials hold. Native proof `.epiphany-smoke\repo-work-readiness-20260621-120755` reported `status=closed`, `latestReceiptId=repo-work-readiness-review-repo-work-readiness`, `reviewReceiptCount=4`, `publicArtifactCount=1`, and `privateStateExposed=false`; wrapper proof `local-20260621-131113-240-be2b19f2` printed the same closed accounting row from the repo-local Verse target after `bifrost-ledger` was corrected to read `$localVerseReadStore`. - 2026-06-20: Mind now has explicit repo-work safe-family and requested-path guards before branch-local Hands authority. `adopt --from-plan` treats unsupported plan-derived safe-family labels as refused interpreter decisions, writes `epiphany.repo_work_mind_adoption_decision.v0` with `status=refused-unsupported-safe-family`, keeps `actionItemAccepted=false` and `safeFamilyRecognized=false`, grants no Hands/durable-state/service/publication/cross-body/private-state authority, and writes no normal adoption receipt. It also compares the sorted action-item `requestedPaths` against the sorted plan action `changedPaths`; mismatches write `status=refused-requested-path-mismatch`, keep `safeFamilyRecognized=true` but `requestedPathsMatchPlan=false`, point the next gate at `imagination.replan_with_matching_requested_paths`, and grant no Hands/durable-state/service/publication/cross-body/private-state authority. Focused smokes `.epiphany-smoke\repo-mind-safe-family-guard-20260620-194425` and `.epiphany-smoke\repo-mind-path-guard-20260620-194239` prove both refusal paths; earlier positive smokes `.epiphany-smoke\repo-planning-facets-20260620-190916` and `.epiphany-smoke\closure-model-gate-20260620-190916` prove recognized planning facets and closure model gates still pass. Current remaining repo-swarm MVP organs are deeper interpreter semantics beyond adoption refusal, more useful repo-owned configuration/action families, richer closure depth, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: Mind now also refuses plan-derived repo work that is not evidence-ready. `derive-plan` embeds verification asks in the Imagination action-item receipt, `adopt --from-plan` records verification asks and planning evidence needs in `epiphany.repo_work_mind_interpretation.v0`, and empty verification asks or evidence needs write `status=refused-missing-evidence-needs` with next gate `imagination.replan_with_explicit_soul_evidence_needs`. The refusal grants no Hands, durable-state, service, publication, cross-body, or private-state authority and writes no adoption receipt. Focused proof `.epiphany-smoke\repo-mind-evidence-guard-20260620-224426` tampers both arrays empty and proves the refusal; regression `.epiphany-smoke\repo-planning-facets-20260620-224428` proves normal planning facets still close through Soul/Modeling/Mind. - 2026-06-20: `repo-eve-surface` is now live as repo-owned Eve/CultUI surface contract cargo. `epiphany-work derive-plan --action-family repo-eve-surface` writes `.epiphany/eve-surfaces/.toml` with safe family `repo.eve_surface`, compact agent TUI and GUI lowering contracts, local/public Verse routing, Odin discovery, provider-owned surface identity, Persona/human collaboration flags, feedback routing to Imagination, and denials for renderer ownership, rendering/state/publication/service/cross-body authority, private Verse rummaging, and private-state exposure. Soul closure assertions inspect schema, family, summary, surface routing, Verse routing, CultUI contracts, collaboration route, authority seals, and private-state seal. Focused smoke `.epiphany-smoke\repo-eve-surface-family-20260620-165927` ran init -> online -> accept -> repo-eve-surface derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/eve-surfaces/repo-eve-surface-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `hasCultUiContracts=true`, `hasVerseRouting=true`, `odinDiscoverable=true`, `feedbackRoutesToImagination=true`, `rendererOwnsTruth=false`, `renderingAuthority=false`, `stateAuthority=false`, `publicationAuthority=false`, `serviceLifecycleAuthority=false`, `crossBodyMutationAuthority=false`, `privateVerseRummaging=false`, 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. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 79482afc27c1b06c2c324ae7193adbf56c6a1974..e9c4b88b5c3b585cbc158faba46d71da6cfcd3dc 100644 GIT binary patch delta 391 zcmXX>Jxc>Y5cMuD2!aripwVJQt-{6I&4(D1LIlB9#KP`!w@DVxy>oXjCuk=qmZD(` z5j(3y5>lvtz@K4bXQltZy(Gmj!+SID&3pXHJb!2Ui^eR%l@dDnoC5vJ;hJ$~7#CL^ z^QL1Ox{{vKHT~8x!F4zN@PTbyw(PQn(UCqx_jkEv(>zvxw;(&mf*4Zf`jJNjh5w$8;&c-C{pPzSXVz!AhT3J2o)?`w5>Y9b+p~UlUI}-qzdZ& g6|7p);Y}h1beNZfV0ujQPF`|cH}Oi6@*vLt1H65S)Bpeg delta 53 zcmbRLSZww^u?-T8+y;hLMg~#G7+BZ-*sRQ0$jDgLJe8?^Dib3RgJ@Imagination` / `owner=Imagination`, `public=`, candidate action refs, consensus packet ref, adoption gate, and `private=false`; wrapper proof `local-20260618-224207-941-2ca01b41` prints both rows in `feedbackRows`, including Persona public discussion feedback routed to Imagination consensus discovery before Mind/Bifrost adoption. - `epiphany-verse-query bifrost-publication` and `tools/epiphany_local_run.ps1 -Mode bifrost-publication` provide the non-mutating Bifrost body-change publication proof path. It writes Bifrost intent, Bifrost publication receipt, and GitHub publication receipt documents from explicit review/verification/credit inputs, verifies latest keys through narrow CultMesh loaders, publishes follow-on command hints for swarm overview, tool directory, and wrapper Bifrost publication readback, and exposes no private state. - - `epiphany-verse-query bifrost-ledger` and `tools/epiphany_local_run.ps1 -Mode bifrost-ledger` provide the compact Bifrost ledger sight organ. It reads only the latest Bifrost body-change intent, Bifrost publication receipt, GitHub publication receipt, public-proof publication receipt, collaboration feedback, and Imagination consensus receipt through narrow CultMesh loaders, returns agent-friendly ledger TUI rows, publishes follow-on command hints for swarm overview, tool directory, collaboration feedback, Bifrost publication, and Bifrost ledger readback, and exposes no private state. Compact ledger rows carry explicit `owner=`, `public=`, and `private=false`, so body-change/public-feedback proof is inspectable without opening raw local Verse payloads or inferring authority from document names. Bifrost ledger readback now also derives three `BIFROST-ACCOUNTING` rows for `body-change-publication`, `public-proof-publication`, and `collaboration-consensus`, with closure status, ledger/receipt/public refs, review and credit receipt counts, artifact count, and private-state seal. Wrapper proof `local-20260621-091019-297-aaf2ad07` printed `accountingRows=3`, `closedAccounting=2`, `attentionAccounting=0`, closed body-change and collaboration rows, a visible missing public-proof-publication row, and `privateStateExposed=False`. + - `epiphany-verse-query bifrost-ledger` and `tools/epiphany_local_run.ps1 -Mode bifrost-ledger` provide the compact Bifrost ledger sight organ. It reads only the latest Bifrost body-change intent, Bifrost publication receipt, GitHub publication receipt, public-proof publication receipt, repo-work readiness-review receipt, collaboration feedback, and Imagination consensus receipt through narrow CultMesh loaders, returns agent-friendly ledger TUI rows, publishes follow-on command hints for swarm overview, tool directory, collaboration feedback, Bifrost publication, and Bifrost ledger readback, and exposes no private state. Compact ledger rows carry explicit `owner=`, `public=`, and `private=false`, so body-change/public-feedback proof is inspectable without opening raw local Verse payloads or inferring authority from document names. Bifrost ledger readback now derives four `BIFROST-ACCOUNTING` rows for `body-change-publication`, `public-proof-publication`, `repo-work-readiness-review`, and `collaboration-consensus`, with closure status, ledger/receipt/public refs, review and credit receipt counts, artifact count, and private-state seal. Readiness-review accounting closes only when latest `epiphany.cultmesh.repo_work_readiness_review.v0` has four Maintainer/Soul/Mind/Bifrost review refs, readiness approval, zero missing required rows, present review artifact, and no durable-state/publication/merge/sync/deployment/service/Hands/private authority. Native proof `.epiphany-smoke\repo-work-readiness-20260621-120755` reported the closed row with `reviewReceiptCount=4`, `publicArtifactCount=1`, and `privateStateExposed=false`; wrapper proof `local-20260621-131113-240-be2b19f2` proved `bifrost-ledger` honors explicit repo-local Verse read targets. - `epiphany-verse-query receipt-directory` and `tools/epiphany_local_run.ps1 -Mode receipt-directory` provide the compact latest-witness directory over local Verse. It indexes operator run, daemon poke, daemon tool invocation, Eve connection, Bifrost publication, Imagination consensus, coordinator run, Hands gate, role review, work-loop, cluster service lifecycle, single-service lifecycle, cluster service execution runbook, single-service execution runbook, scheduler, Persona speech, and agent-state SoA witness families from typed local Verse projections; returns agent-friendly `OK`/`ABSENT`/`ATTN` TUI rows with owner, family, status, route, latest id, follow-up command, `presentRowCount`, and `absentRowCount`; preserves `missingRowCount` as compatibility for absent witnesses; flags sealed service lifecycle failure states such as `not-elevated`, `execution-refused-not-elevated`, and `incomplete` as attention without exposing receipt payloads; routes service lifecycle receipts by their typed receipt action through `service_execution_check_follow_up_command` (readiness to readiness, install to install execute, start/stop to control execute, status/reconcile to their readback rites, audit to audit), while cluster/single execution-runbook witnesses route to their runbook regeneration wrappers; and exposes no private state or receipt payload previews. The lifecycle projection now reads the typed receipt family, splits `cluster-service-lifecycle` from `service-lifecycle`, selects the latest attention receipt before falling back to latest overall, and exposes `service-id::action` route values such as `epiphany-cluster-daemon-services::cluster-windows-service-execution-audit`, so agents can see the owning lifecycle action without opening raw audit JSON. Compact receipt TUI rows append `followUp=`, artifact status, and SHA-256; wrapper proof `local-20260618-205920-451-383b0da7` now prints all seventeen compact rows in `receiptRows`, including missing Hands/role/work-loop gates, runbook hashes, scheduler follow-up, Bifrost/Imagination witnesses, and the active service lifecycle attention rows. It also exposes `cluster-service-execution-runbook` plus `service-execution-runbook` as display-only rows, so newer harmless planned/runbook lifecycle receipts cannot hide the active seven-service cluster wound. Receipt-directory JSON now carries Rust-owned `attentionRouteRows` derived from the same policy predicate as `attentionRowCount`, and the wrapper prints that field instead of rebuilding attention from ad hoc status strings; source smoke now proves a `cluster-windows-service-execution-readiness` receipt routes to `cluster-service-execution-readiness` and wrapper mode `cluster-service-execution-readiness` instead of laundering the row through audit. Live proof `local-20260618-212134-758-c7c56240` left the old degraded Hands daemon-poke receipt as an `OK` historical witness while attention routes named only the cluster and single-service lifecycle wounds. Daemon-poke rows now resolve historical receipt status against current daemon liveness: source smoke proves degraded remains degraded before heartbeat recovery and becomes `resolved` after current status returns ready, while live wrapper proof `local-20260618-212649-563-48647018` printed the old Hands poke receipt as `OK | Self | daemon-poke | resolved`. - `tools/epiphany_local_run.ps1 -Mode service-tick` is the wrapper-owned daemon scheduler pulse rite. It runs `epiphany-daemon-supervisor tick` through the same local Verse store, operator run intent/receipt, agent-state SoA refresh, and swarm-brake preflight as other service lifecycle modes, but leaves restart authority inside durable daemon restart policies. The receipt directory scheduler row now follows up with `tools/epiphany_local_run.ps1 -Mode service-tick` instead of passive service status. Proof seeded one disabled Persona restart policy as inert policy metadata, then the wrapper wrote `daemon-scheduler-receipt-epiphany-daemon-supervisor-0` with `status=tickComplete`, `outcomeCount=1`, `skippedCount=1`, `restartedCount=0`, `refusedCount=0`, and `privateStateExposed=false`; the follow-up receipt-directory proof reported the scheduler row as present with route `*`, follow-up command `service-tick`, and no private-state exposure. - `epiphany-cluster-daemon` is the first real per-cluster daemon heartbeat body. It runs as a narrow Rust binary parameterized by daemon id, publishes typed `epiphany.cultmesh.daemon_status.v0` heartbeats into the shared local Verse, can run once or loop, and exposes no private state. Durable restart policies for Self, Hands, Persona, Imagination, Eyes, Modeling, and Soul now invoke `epiphany-cluster-daemon heartbeat`, not the generic query/debug writer. A degraded proof showed `service-tick` invoking all seven daemon bodies through the supervisor and restoring ready liveness with sealed scheduler/poke receipts; a fresh tick no-ops when all heartbeats are current. `epiphany-daemon-supervisor cluster-service-runbook` and wrapper `-Mode cluster-service-runbook` write a non-mutating service runbook plus `daemon_service_lifecycle` receipt for all seven organ daemon `epiphany-cluster-daemon serve` commands. Direct `service-runbook` and `cluster-service-runbook` wrapper summaries now print local artifact SHA-256 plus follow-up/aftercare wrapper routes; live proofs `local-20260618-232133-314-4e55120e` and `local-20260618-232146-541-982dd60b` showed hashes `85a956f768e584a9d098f13a9bf03fc3560915821a2ae7eaab94889dd9ecda85` and `40616423a9210101486949d07291bf795175579a39e99de5e5a759f8e0d7a78c` without service mutation. Wrapper `service-plan` and `service-launch` now expose the native daemon-supervisor service lifecycle surfaces under the same brake gate; `service-launch` silences child stdout/stderr so the parent lifecycle receipt remains the only stdout JSON. Live proof `local-20260618-232935-349-7e3901c8` completed a bounded one-iteration launch with `exitCode=0` and no private-state exposure. `epiphany-daemon-supervisor cluster-service-install-plan` and wrapper `-Mode cluster-service-install-plan` write a non-mutating Windows install script plus lifecycle receipt for seven distinct per-organ Windows services. Wrapper `-Mode cluster-service-install-execute` requests execution through the same typed path and, in non-elevated shells, writes `execution-refused-not-elevated` with `executed=false` instead of mutating services. Direct cluster install wrapper summaries now include `artifactSha256=` and `followUp=tools/epiphany_local_run.ps1 -Mode cluster-service-install-execute`; live proofs `local-20260618-230937-335-71c4fdaa` and `local-20260618-230937-313-cb288388` showed the planned and non-elevated-refused cluster install artifact hash `c6b697e173eb319073da341fc90c2963bcd6bee63d804349205b6309c88df764`. `epiphany-daemon-supervisor cluster-service-audit` and wrapper `-Mode cluster-service-audit` read Windows service-manager state for those seven expected service names, writing an incomplete audit receipt when they are missing; direct audit summaries now point missing cluster services to `cluster-service-install-plan` plus `cluster-service-execution-audit` aftercare, with live proof `local-20260618-232200-992-b842ae01` reporting seven missing services and no mutation. `epiphany-daemon-supervisor cluster-service-start`/`cluster-service-stop` and wrapper `-Mode cluster-service-start-plan`, `cluster-service-stop-plan`, `cluster-service-start-execute`, and `cluster-service-stop-execute` record cluster lifecycle receipts for all seven services: plan modes emit seven `*-planned` rows without mutation, and explicit execute modes refuse as `execution-refused-not-elevated` with seven refused rows when the shell lacks service authority. The cluster install/audit/control wrapper summaries now print compact `serviceRows` for all seven daemon-owned Windows service names with daemon id, status or observed status, cluster id, executed flag, exit code, start type, and `private=false`; live proofs `local-20260618-211051-126-2a89d61c`, `local-20260618-211051-125-cd687ee2`, `local-20260618-211051-063-f0ff980d`, and `local-20260618-211118-108-df5cb8cd` show seven missing audit rows, seven ready/demand install-plan rows, seven start-planned rows, and seven stop-planned rows without service mutation. `cluster-service-execution-runbook` writes an admin-gated wrapper sequence for cluster-native readiness, cluster install, cluster start, cluster audit, cluster stop, and final cluster audit; the artifact now uses `Invoke-EpiphanyRunbookStep` to reset `$LASTEXITCODE`, catch thrown/nonzero failures, continue gathering receipts after a failed step, and always runs `cluster-service-execution-audit` from `finally`; generated child execution runbooks no longer use `Invoke-Expression`, and each step invokes the known wrapper `ScriptPath` with an explicit `Arguments` array. The wrapper calls `epiphany-daemon-supervisor cluster-service-execution-runbook` after artifact generation, so the runbook itself has a typed `daemon_service_lifecycle` receipt with action `cluster-windows-service-execution-runbook`, status `written`, artifact path, final-audit metadata, step-failure policy metadata, and `privateStateExposed=false`. Its wrapper JSON and typed receipt args expose `runbookTryModes`, `finalAuditMode=cluster-service-execution-audit`, `finalAuditRunsInFinally=true`, `stepFailurePolicy=continue-after-step-failure`, `continueAfterStepFailure=true`, `nonzeroExitFailsStep=true`, and `exitsNonzeroAfterFinalAudit=true`; direct wrapper summaries now print the exact `elevatedCommand=Start-Process PowerShell -Verb RunAs -Wait ...` invocation, `artifactSha256=`, and `aftercare=tools/epiphany_local_run.ps1 -Mode cluster-service-execution-audit`. Live proof `local-20260619-010940-407-b0744f08` generated the robust cluster artifact and printed hash `bf116ed4fd5bb2c9dc77f5032d19e792b012941a60b109389b79e5fcb0a2a5f6` without service mutation. `cluster-service-execution-audit` first requires the sealed `cluster-windows-service-execution-runbook` receipt, then checks the latest cluster-native readiness plus cluster install/start/audit/stop lifecycle receipts by receipt timestamp and reports `complete` only when the runbook and elevated effect receipts are sealed and successful. Audit check rows retain lifecycle `operatorArtifactRef`; wrapper summaries now print OK runbook witnesses with SHA-256 before compact failed-check anatomy. Live proof `local-20260618-170322-330-e6cb2117` printed `cluster-windows-service-execution-runbook=...\epiphany-cluster-daemon-services-execution-runbook.ps1:sha256=3239ac17008b1ce857970e40b17d37a1ecf1631a3a6636bb2b8678312fb604a0` and the expected five failed checks without mutating Windows services. @@ -649,5 +649,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: Repo-work readiness review proof is now visible in both Gjallar and receipt-directory. `epiphany-work readiness-review` consumes a ready `epiphany.repo_work_readiness_report.v0`, requires Maintainer, Soul, Mind, and Bifrost review refs, writes `epiphany.repo_work_readiness_review_receipt.v0`, and mirrors approved review receipts into local Verse as `epiphany.cultmesh.repo_work_readiness_review.v0`. Gjallar/swarm-overview/triage project `REPO-WORK-READINESS-REVIEW` rows and a non-mutating action row with readiness approval true but durable-state, publication, merge, upstream-sync, deployment, service lifecycle, Hands, and private-state authority false. `epiphany-verse-query receipt-directory` now indexes the same review as `repo-work-readiness-review` with review artifact status/SHA-256 and private-state seal, and wrapper `receipt-directory` honors explicit repo-local Verse read targets. Native proof `.epiphany-smoke\repo-work-readiness-20260621-115547` reported `latestId=repo-work-readiness-review-repo-work-readiness`, `artifactStatus=present`, SHA-256 `ba50bce3aa2af320a71977bde9d47108154665802dd527dd30bf8c4ab28bba5e`; wrapper proof `local-20260621-125756-748-03710f48` printed the row from the repo-local Verse target. - next_action: Continue repo-swarm MVP work from `notes/epiphany-repo-swarm-mvp-contract.md`. Useful next cuts are deeper Bifrost-first external-work accounting if ledger/publication readback needs more cargo, another useful repo-owned safe action family if needed, or explicit elevated/operator Idunn execution proof only when the human grants that authority. Persona-to-Imagination consensus readback, Mind-owned interpreter brief cargo, safe-family planning depth and closure, Gjallar closure/readiness/readiness-review rows, receipt-directory readiness-review indexing, Bifrost ledger accounting rows, readiness wrapper mouth, repo deployment handoff/readback wrappers, readiness deployment-aftercare closure, readiness Idunn/tool-directory receipt validation, readiness Bifrost/GitHub publication-chain validation, readiness upstream-main sync validation, and readiness review/adoption receipt validation are sealed; preserve Idunn service lifecycle ownership, Bifrost publication/upstream-main ownership, Mind durable-state admission, and existing CultMesh/Odin/Eve tool directories. Windows service install/start/deployment execution still requires explicit elevated operator authority. + last_completed_repo_swarm_cut: Repo-work readiness review proof is now visible in Gjallar, receipt-directory, and Bifrost ledger accounting. `epiphany-work readiness-review` consumes a ready `epiphany.repo_work_readiness_report.v0`, requires Maintainer, Soul, Mind, and Bifrost review refs, writes `epiphany.repo_work_readiness_review_receipt.v0`, and mirrors approved review receipts into local Verse as `epiphany.cultmesh.repo_work_readiness_review.v0`. Gjallar/swarm-overview/triage project `REPO-WORK-READINESS-REVIEW` rows and a non-mutating action row with readiness approval true but dangerous authority false. `receipt-directory` indexes the review artifact/ref/SHA. `bifrost-ledger` now derives a closed `repo-work-readiness-review` accounting row when approval status, four review refs, present artifact, zero missing rows, and all dangerous authority denials hold. Native proof `.epiphany-smoke\repo-work-readiness-20260621-120755` reported the closed accounting row; wrapper proof `local-20260621-131113-240-be2b19f2` printed it from the repo-local Verse target. + next_action: Continue repo-swarm MVP work from `notes/epiphany-repo-swarm-mvp-contract.md`. Useful next cuts are deeper external-work metrics/accepted-artifact accounting, another useful repo-owned safe action family if needed, or explicit elevated/operator Idunn execution proof only when the human grants that authority. Persona-to-Imagination consensus readback, Mind-owned interpreter brief cargo, safe-family planning depth and closure, Gjallar closure/readiness/readiness-review rows, receipt-directory readiness-review indexing, Bifrost ledger accounting rows including readiness-review closure, readiness wrapper mouth, repo deployment handoff/readback wrappers, readiness deployment-aftercare closure, readiness Idunn/tool-directory receipt validation, readiness Bifrost/GitHub publication-chain validation, readiness upstream-main sync validation, and readiness review/adoption receipt validation are sealed; preserve Idunn service lifecycle ownership, Bifrost publication/upstream-main ownership, Mind durable-state admission, and existing CultMesh/Odin/Eve tool directories. Windows service install/start/deployment execution still requires explicit elevated operator authority. diff --git a/tools/epiphany_local_run.ps1 b/tools/epiphany_local_run.ps1 index c2804d14..f2e428e6 100644 --- a/tools/epiphany_local_run.ps1 +++ b/tools/epiphany_local_run.ps1 @@ -890,7 +890,7 @@ if ($Mode -eq "bifrost-ledger") { -FilePath $verseQueryExe ` -Arguments @( "bifrost-ledger", - "--store", $localVerseStore, + "--store", $localVerseReadStore, "--runtime-id", $LocalVerseRuntimeId ) ` -WorkingDirectory $Root `