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 d2251717..cbdf88e4 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 @@ -503,6 +503,36 @@ fn run_smoke(args: Args) -> Result { "Gjallar TUI rows did not expose compact repo map sight" )); } + require_u64(&gjallar, &["repoWorkMapFamilyLensCount"], 1)?; + let family_lens_rows = value_at_path(&gjallar, &["repoWorkMapFamilyLensRows"]) + .and_then(Value::as_array) + .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapFamilyLensRows array"))?; + let family_lens_row = family_lens_rows + .iter() + .find(|row| { + row.get("safeActionFamily").and_then(Value::as_str) + == Some("repo.markdown_planning_note") + }) + .ok_or_else(|| anyhow!("Gjallar output had no repo map family lens row"))?; + require_eq_value(family_lens_row, &["latestItem"], item)?; + require_eq_value( + family_lens_row, + &["latestMindStateCommitReceiptId"], + &map_entry.mind_state_commit_receipt_id, + )?; + require_bool_value(family_lens_row, &["privateStateExposed"], false)?; + let family_lens_tui_rows = value_at_path(&gjallar, &["repoWorkMapFamilyLensTuiRows"]) + .and_then(Value::as_array) + .ok_or_else(|| anyhow!("Gjallar output had no repoWorkMapFamilyLensTuiRows array"))?; + if !family_lens_tui_rows.iter().any(|row| { + row.as_str().is_some_and(|row| { + row.contains("REPO-WORK-MAP-LENS") && row.contains("repo.markdown_planning_note") + }) + }) { + return Err(anyhow!( + "Gjallar TUI rows did not expose repo map family lens sight" + )); + } let summary = json!({ "schemaVersion": "epiphany.repo_close_mind_adoption_guard_smoke.v0", @@ -523,6 +553,7 @@ fn run_smoke(args: Args) -> Result { "repoMapDurableStateAdmitted": map_entry.durable_state_admitted, "repoMapLocalVerseProjected": true, "gjallarLatestRepoWorkMapEntry": gjallar["latestRepoWorkMapEntry"], + "gjallarRepoWorkMapFamilyLensCount": gjallar["repoWorkMapFamilyLensCount"], "publicationAuthorized": false, "privateStateExposed": false }); @@ -660,6 +691,22 @@ fn require_bool(value: &Value, path: &[&str], expected: bool) -> Result<()> { } } +fn require_u64(value: &Value, path: &[&str], expected: u64) -> Result<()> { + let actual = value_at_path(value, path) + .and_then(Value::as_u64) + .ok_or_else(|| anyhow!("missing unsigned integer at {}", path.join(".")))?; + if actual == expected { + Ok(()) + } else { + Err(anyhow!( + "expected {} to be {}, got {}", + path.join("."), + expected, + actual + )) + } +} + fn require_eq_value(value: &Value, path: &[&str], expected: &str) -> Result<()> { let actual = value_at_path(value, path) .and_then(Value::as_str) diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs index 0ca3360e..8464e007 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -4069,6 +4069,8 @@ struct SwarmOverviewReport { service_execution_failed_check_tui_rows: Vec, repo_work_map_rows: Vec, repo_work_map_tui_rows: Vec, + repo_work_map_family_lens_rows: Vec, + repo_work_map_family_lens_tui_rows: Vec, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, repo_work_public_proof_rows: Vec, @@ -4126,6 +4128,19 @@ struct RepoWorkMapRow { private_state_exposed: bool, } +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +struct RepoWorkMapFamilyLensRow { + safe_action_family: String, + item_count: usize, + changed_path_count: usize, + 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 { @@ -4231,6 +4246,9 @@ struct SwarmOverviewOutput { repo_work_map_count: usize, repo_work_map_rows: Vec, repo_work_map_tui_rows: Vec, + repo_work_map_family_lens_count: usize, + repo_work_map_family_lens_rows: Vec, + repo_work_map_family_lens_tui_rows: Vec, repo_work_overview_count: usize, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, @@ -4306,6 +4324,9 @@ impl SwarmOverviewOutput { repo_work_map_count: report.repo_work_map_rows.len(), repo_work_map_rows: report.repo_work_map_rows, repo_work_map_tui_rows: report.repo_work_map_tui_rows, + repo_work_map_family_lens_count: report.repo_work_map_family_lens_rows.len(), + repo_work_map_family_lens_rows: report.repo_work_map_family_lens_rows, + repo_work_map_family_lens_tui_rows: report.repo_work_map_family_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, @@ -4373,6 +4394,9 @@ struct SwarmTriageOutput { repo_work_map_count: usize, repo_work_map_rows: Vec, repo_work_map_tui_rows: Vec, + repo_work_map_family_lens_count: usize, + repo_work_map_family_lens_rows: Vec, + repo_work_map_family_lens_tui_rows: Vec, repo_work_overview_count: usize, repo_work_overview_rows: Vec, repo_work_overview_tui_rows: Vec, @@ -4443,6 +4467,9 @@ impl SwarmTriageOutput { repo_work_map_count: report.repo_work_map_rows.len(), repo_work_map_rows: report.repo_work_map_rows, repo_work_map_tui_rows: report.repo_work_map_tui_rows, + repo_work_map_family_lens_count: report.repo_work_map_family_lens_rows.len(), + repo_work_map_family_lens_rows: report.repo_work_map_family_lens_rows, + repo_work_map_family_lens_tui_rows: report.repo_work_map_family_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, @@ -5044,6 +5071,56 @@ fn repo_work_map_tui_row(row: &RepoWorkMapRow) -> String { ) } +fn repo_work_map_family_lens_rows( + repo_work_map_entries: &[EpiphanyCultMeshRepoWorkMapEntry], +) -> (Vec, Vec) { + let mut by_family = BTreeMap::::new(); + for entry in repo_work_map_entries { + let family = entry.safe_action_family.clone(); + let row = by_family + .entry(family.clone()) + .or_insert_with(|| RepoWorkMapFamilyLensRow { + safe_action_family: family, + item_count: 0, + changed_path_count: 0, + 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(); + 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_family.into_values().collect::>(); + let tui_rows = rows + .iter() + .map(repo_work_map_family_lens_tui_row) + .collect::>(); + (rows, tui_rows) +} + +fn repo_work_map_family_lens_tui_row(row: &RepoWorkMapFamilyLensRow) -> String { + format!( + "REPO-WORK-MAP-LENS | family={} | items={} | paths={} | latestItem={} | latestCommit={} | latestMind={} | gate={} | private={}", + row.safe_action_family, + row.item_count, + row.changed_path_count, + 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| { @@ -5871,6 +5948,8 @@ fn load_swarm_overview_report(args: &Args) -> Result { let (repo_work_overview_rows, repo_work_overview_tui_rows) = repo_work_overview_rows(&repo_work_overviews); let (repo_work_map_rows, repo_work_map_tui_rows) = repo_work_map_rows(&repo_work_map_entries); + let (repo_work_map_family_lens_rows, repo_work_map_family_lens_tui_rows) = + repo_work_map_family_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( @@ -5895,6 +5974,9 @@ fn load_swarm_overview_report(args: &Args) -> Result { || repo_work_map_entries .iter() .any(|entry| entry.private_state_exposed) + || repo_work_map_family_lens_rows + .iter() + .any(|row| row.private_state_exposed) || repo_work_public_proofs .iter() .any(|proof| proof.private_state_exposed) @@ -5944,6 +6026,8 @@ fn load_swarm_overview_report(args: &Args) -> Result { service_execution_failed_check_tui_rows, repo_work_map_rows, repo_work_map_tui_rows, + repo_work_map_family_lens_rows, + repo_work_map_family_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 4babef6a..ef410257 100644 --- a/notes/epiphany-repo-swarm-mvp-contract.md +++ b/notes/epiphany-repo-swarm-mvp-contract.md @@ -1175,6 +1175,15 @@ source map store ref, and `privateStateExposed=false`. The cargo-run smoke itself completed and wrote `summary.json` after the outer tool timeout, so the independent Gjallar readback is the clean terminal proof. +The next smoke tightened that map sight into the first semantic lens: +`.epiphany-smoke\repo-close-mind-adoption-guard-20260620-205055` proves Gjallar +now derives `repoWorkMapFamilyLensRows` and `REPO-WORK-MAP-LENS` TUI rows from +Mind-admitted map entries, grouping by safe action family with item count, +changed-path count, latest item, latest commit, latest Mind commit receipt, +Bifrost gate, and `privateStateExposed=false`. This lens is still read-only +Gjallar sight; it does not own scheduling, publication, merge, deployment, or +Mind admission. + `epiphany-work overview` is the first compact repo work sight/proof surface: ```powershell @@ -1524,7 +1533,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, 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, 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. | @@ -2029,7 +2038,7 @@ Required organs before MVP: `gamecult.bifrost.public_proof_publication_receipt.v0` with public Verse target, public room, ledger, review, credit, proof ref, and SHA-256 readback. Remaining work is deeper semantic review and richer map updates/lenses beyond - latest work-item consequence; it is not basic safe-family planning cargo, + latest work-item consequence and family-level aggregation; it is not basic safe-family planning cargo, local public-proof export, local CultMesh readback, Bifrost/GitHub/sync row visibility, public-proof publication closure, Mind-adoption closure proof, first durable repo-map admission, first durable repo-map local Verse diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 4cf1fd85..2015edc4 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -123,6 +123,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-20: `notes/epiphany-repo-swarm-mvp-contract.md` now has the explicit functional-swarm answer. The current seventeen front doors are real proof surfaces, not decorative wrapper smoke, but Epiphany is not fully online until the typed artery can run as a living repo organism: deeper model-authored closure review, further non-planning action classes, Idunn-owned queue-run service lifecycle under explicit operator authority. Use that section when answering whether Epiphany is headed toward a functional swarm. - 2026-06-20: Gjallar/swarm-overview now exposes repo-work overview history as first-class compact sight, Persona's public Eve surface lowers the same queue for peer-readable collaboration, and Self has a first runnable queue surface over it. `SwarmOverviewOutput` and `SwarmTriageOutput` include `repoWorkOverviewCount`, `repoWorkOverviewRows`, `repoWorkOverviewTuiRows`, `latestRepoWorkOverview`, `latestRepoWorkGate`, `latestRepoWorkBlocker`, and `latestRepoWorkNextSafeMove`; the shared `swarmActionRows` queue gets priority 35 `repo-work-overview` rows owned by Gjallar, hosted body `repo-work`, authority gate `repo.work.overview`, effect class `repo-work-readback`, no mutation, no elevation, proof-bundle ref, and private-state seal. `eve-surfaces`, direct `connect-eve`, and the globally invokable Persona `eve-connect` daemon tool readback expose public `REPO-WORK-PEER` rows with item, gate, blocker, next safe move, branch, publication, sync, and `private=false`. `epiphany-work queue-run` reads the same typed queue, selects current-repo rows at `ready-to-run`, `ready-to-adopt`, `ready-to-execute`, or `awaiting-closure`, delegates to `tick`, refreshes overview after real advancement, and wrapper `repo-work-queue-run` exposes the operator 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` prove two-item queue sight, Eve lowering, direct queue-run advancement, and wrapper dry-run without publication, merge, service lifecycle mutation, elevation, cross-repo mutation, or private-state exposure. The next cut is deeper model-authored closure review, further non-planning action classes, or Idunn-owned queue-run service execution; not another queue display surface. - 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: 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 155b15fc..2b570f11 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 90374386..41de66d7 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -90,6 +90,7 @@ active_subgoals: - Use `notes/epiphany-swarm-readiness-plan.md` as the live-fire direction gate. The local run path is a compass, not launch clearance: before unattended swarm operation, Epiphany needs typed pause/brake enforcement, one initiative scheduler, completion-gated cooldown, stale active-turn recovery receipts, parent-side Persona speech eligibility, memory lifecycle operations, and CultNet-first operator snapshots/intents/receipts. The local Verse brake document exists, `epiphany-verse-query swarm-brake` can engage/release it, `tools/epiphany_local_run.ps1` refuses live `plan`/`run`/`mvp` modes when the brake is engaged while leaving `status` readable, `epiphany-mvp-coordinator` checks the local Verse brake before app-server startup, and `epiphany-heartbeat-store` guards tick/pump/heat/queue-mention/routine when given `--local-verse-store`. Daemon liveness is now a typed local Verse authority: `epiphany-verse-query daemon-status` writes one daemon status without repainting the table, local Verse seeding preserves existing daemon statuses and swarm brakes, `invoke-tool` refuses when the host daemon is not ready or lacks `submitTypedToolIntent`, and both daemon tool invocation and lifecycle poke fail closed under an engaged matching brake. `epiphany-daemon-supervisor policy` writes durable per-daemon restart policy with command/args/cwd/cooldown/backoff/attempt state plus reconcile cadence and stale-heartbeat threshold; `epiphany-daemon-supervisor reconcile` loads that policy when no override command is supplied, refuses under a matching lifecycle brake, refuses during cooldown/backoff, writes daemon poke intent/receipt, updates daemon status, and updates policy attempt state; `epiphany-daemon-supervisor tick` is an explicit scheduler pulse that scans durable policies, records ready/noop pulses, skips before the configured reconcile interval, marks stale heartbeat status degraded, routes restarts through the same brake/cooldown/poke receipt path, and writes a latest `epiphany.cultmesh.daemon_scheduler_receipt.v0`; `epiphany-daemon-supervisor serve` runs that same pulse on a configurable cadence with bounded `--max-iterations` proof mode or unbounded service mode. `epiphany-daemon-supervisor service-plan`/`install-service` now writes a planned `epiphany.cultmesh.daemon_service_lifecycle_receipt.v0` for the `serve` command, while `service-launch`/`start-service` spawns that `serve` loop through the current executable or `--service-command`, can `--wait-child` for bounded proof, and records command/args/cwd, scheduler id, daemon selector, pid/exit/status, artifact ref, and private-state guard. `service-runbook`, `windows-service-install`/`service-install-plan`, `windows-service-status`, `windows-service-reconcile`, `windows-service-execution-readiness`, and `windows-service-start`/`stop` now record service lifecycle receipts through the same local Verse; the read-only status path has been proved against the real Windows `EventLog` service with receipt `daemon-service-lifecycle-receipt-windows-eventlog-proof-windows-service-status`, status `running`, exit code `0`, and `privateStateExposed=false`; the read-only service-policy reconciliation path has been proved for missing service, real-service drift against `EventLog`, lifecycle-brake refusal, and wrapper/local-Verse receipt `daemon-service-lifecycle-receipt-windows-eventlog-reconcile-proof-windows-service-reconcile`; execution readiness has been proved as a non-mutating `not-elevated` receipt through direct and wrapper paths; start/stop now produce non-mutating `start-planned`/`stop-planned` receipts unless `--execute-control`/`--execute-service-control` is passed, and wrapper `service-start-plan`/`service-stop-plan` proves those receipts against `EventLog`; explicit install/control execution now refuses as `execution-refused-not-elevated` with `executed=false` when the shell lacks Windows administrator authority, and wrapper `service-install-execute`, `service-start-execute`, and `service-stop-execute` prove those refusal receipts without mutation. Service lifecycle actions check the local Verse swarm brake before process launch, artifact writes, service-manager queries, service-policy reconciliation, execution-readiness checks, control planning, elevation-gated execution, or start/stop execution. The local wrapper builds/checks this binary. - Use `notes/epiphany-repo-swarm-mvp-contract.md` as the repo-swarm autonomy authority map. Autonomous branch-local work inside an Epiphany-owned repo Body is in scope and desired; the safety boundary is typed authority, branch containment, interruption, receipts, private-state sealing, and Bifrost-gated publication/merge/escalation, not asking a human before every local edit. Current safe-family cargo includes repo manifest, tool capability manifest, daemon-hosted tool request cargo, Eve/CultUI surface contract, repo collaboration policy, collaboration topics, consensus/objective/adoption/scheduling/work-order/verification/publication/sync/review/PR/credit/artifact/metrics/doctrine-update/secret-policy/deployment requests, action-item receipts, Mind adoption interpretation/decision receipts, explicit Mind safe-family refusal proof `.epiphany-smoke\repo-mind-safe-family-guard-20260620-194425`, explicit Mind requested-path/plan changed-path refusal proof `.epiphany-smoke\repo-mind-path-guard-20260620-194239`, overview/public-proof/Gjallar/Eve readbacks, typed swarm-run stop classification, Idunn non-mutating queue-run lifecycle receipts, and fresh-repo upstream-main proof. Latest deployment cargo proof `.epiphany-smoke\repo-deployment-request-family-20260620-195605` shows `repo.deployment_request` closes through Soul while requesting reviewed git-push-observed-by-Idunn deployment with script/host/secret/rollback/aftercare requirements and no deployment/SSH/git-push/service authority. Latest security cargo proof `.epiphany-smoke\repo-secret-policy-request-family-20260620-193046` shows `repo.secret_policy_request` closes through Soul while requesting reviewed secret/write/export/deployment policy without exposing secrets or granting write/deployment/publication authority. Governance proof `.epiphany-smoke\repo-doctrine-update-request-family-20260620-192140` shows `repo.doctrine_update_request` closes through Soul while requesting reviewed `AGENTS.md` doctrine work without mutating doctrine or granting Hands/service/publication authority. Swarm-run stop proofs now include `.epiphany-smoke\fresh-repo-mvp-20260620-180024` for `iteration-limit` / Self / `self.scheduler-iteration-limit` with upstream-main sync and public-proof export, plus `.epiphany-smoke\swarm-stop-classification-20260620-184717` for `queue-empty` / Gjallar / `repo.work.overview`, `dry-run-preview` / Self / `ready-to-run`, `authority-gated` / Bifrost / `awaiting-publication`, and `authority-gated` / Bifrost/GitHub / `awaiting-upstream-sync`; all stop packets are non-mutating, non-elevated, and `privateStateExposed=false`. Native proof `.epiphany-smoke\repo-work-service-lifecycle-20260620-185853` now proves Idunn-owned non-mutating repo-work queue-run service plan/runbook receipts for exact service id `epiphany-repo-work-queue-runner`, receipt-directory readback, runbook SHA-256 `f2ec67c4f8243a3ebc2f9e915b6b9f5ae2ac2d99d2cdb86905b54667adc456f8`, `hostedBody=repo-work`, no service-manager mutation, no launch, no elevation, and `privateStateExposed=false`. - 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/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. @@ -635,5 +636,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: Successful repo-work closure now performs the first durable repo-map admission. `epiphany-work close` writes `.epiphany/state/repo-work-map.msgpack` as typed MessagePack `epiphany.repo_work_map_store.v0`, replacing the item's latest `epiphany.repo_work_map_entry.v0` only after Soul passes, Mind writes gateway/state-commit receipts, and closure remains branch-local/Bifrost-gated. Proof `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-202113` showed a counterfeit Mind-adoption close failed without writing the map, while the original chain wrote a map entry with expected commit SHA, changed path, safe family, Soul verdict id, Mind review/commit ids, `durableStateAdmitted=true`, and `privateStateExposed=false`. + last_completed_repo_swarm_cut: Gjallar now derives the first semantic lens over Mind-admitted repo-work map rows. `epiphany-verse-query gjallar` exposes `repoWorkMapFamilyLensRows` / `REPO-WORK-MAP-LENS`, grouping accepted 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 Mind-adoption guard, closed the original chain, projected the local Verse map row, and passed with `gjallarRepoWorkMapFamilyLensCount=1`. 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.