Project repo work overview into Gjallar

This commit is contained in:
Meta Vens 2026-06-20 01:15:04 +01:00
commit c1e4ac4a47
5 changed files with 202 additions and 5 deletions

View file

@ -743,6 +743,7 @@ fn run_cli() -> Result<()> {
"tools": "epiphany-verse-query tool-directory",
"receipts": "epiphany-verse-query receipt-directory",
"restartPolicies": "epiphany-verse-query restart-policy-directory",
"repoWorkOverview": "epiphany-work overview --workspace <repo> --item <item>",
"pokeNonReady": "epiphany-verse-query poke-down-daemons",
"gjallar": "epiphany-verse-query gjallar",
"wrapperOverview": WRAPPER_OVERVIEW_COMMAND,
@ -3417,6 +3418,7 @@ fn run_cli() -> Result<()> {
&[],
&[],
&[missing_artifact_action],
None,
);
if !missing_artifact_rows.iter().any(|row| {
row.priority == 50
@ -3465,6 +3467,7 @@ fn run_cli() -> Result<()> {
&[],
&[],
&[synthetic_runbook_action],
None,
);
if !synthetic_artifact_rows.iter().any(|row| {
row.priority == 50
@ -3886,6 +3889,12 @@ struct SwarmOverviewReport {
service_execution_missing_check_count: usize,
service_execution_failed_check_rows: Vec<EpiphanyServiceExecutionAuditCheck>,
service_execution_failed_check_tui_rows: Vec<String>,
repo_work_overview_rows: Vec<RepoWorkOverviewRow>,
repo_work_overview_tui_rows: Vec<String>,
latest_repo_work_overview_id: Option<String>,
latest_repo_work_gate: Option<String>,
latest_repo_work_blocker: Option<String>,
latest_repo_work_next_safe_move: Option<String>,
topology_report: ClusterTopologyReport,
daemon_report: DaemonLivenessReport,
surface_report: EveSurfaceReport,
@ -3894,6 +3903,25 @@ struct SwarmOverviewReport {
private_state_exposed: bool,
}
#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct RepoWorkOverviewRow {
overview_id: String,
workspace: String,
item: String,
branch: String,
current_gate: String,
blocker: String,
next_safe_move: String,
changed_path_count: usize,
commit_sha: String,
soul_verdict: String,
publication_status: String,
sync_status: String,
proof_bundle_ref: String,
private_state_exposed: bool,
}
#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct SwarmActionRow {
@ -3975,6 +4003,13 @@ struct SwarmOverviewOutput {
service_execution_missing_check_count: usize,
service_execution_failed_check_rows: Vec<EpiphanyServiceExecutionAuditCheck>,
service_execution_failed_check_tui_rows: Vec<String>,
repo_work_overview_count: usize,
repo_work_overview_rows: Vec<RepoWorkOverviewRow>,
repo_work_overview_tui_rows: Vec<String>,
latest_repo_work_overview: Option<String>,
latest_repo_work_gate: Option<String>,
latest_repo_work_blocker: Option<String>,
latest_repo_work_next_safe_move: Option<String>,
policy_covered_count: usize,
policy_enabled_count: usize,
policy_disabled_count: usize,
@ -4035,6 +4070,13 @@ impl SwarmOverviewOutput {
service_execution_missing_check_count: report.service_execution_missing_check_count,
service_execution_failed_check_rows: report.service_execution_failed_check_rows,
service_execution_failed_check_tui_rows: report.service_execution_failed_check_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,
latest_repo_work_overview: report.latest_repo_work_overview_id,
latest_repo_work_gate: report.latest_repo_work_gate,
latest_repo_work_blocker: report.latest_repo_work_blocker,
latest_repo_work_next_safe_move: report.latest_repo_work_next_safe_move,
policy_covered_count: report.policy_report.covered_count,
policy_enabled_count: report.policy_report.enabled_count,
policy_disabled_count: report.policy_report.disabled_count,
@ -4087,6 +4129,13 @@ struct SwarmTriageOutput {
service_execution_missing_check_count: usize,
service_execution_failed_check_rows: Vec<EpiphanyServiceExecutionAuditCheck>,
service_execution_failed_check_tui_rows: Vec<String>,
repo_work_overview_count: usize,
repo_work_overview_rows: Vec<RepoWorkOverviewRow>,
repo_work_overview_tui_rows: Vec<String>,
latest_repo_work_overview: Option<String>,
latest_repo_work_gate: Option<String>,
latest_repo_work_blocker: Option<String>,
latest_repo_work_next_safe_move: Option<String>,
poked_daemon_count: usize,
pokes: Vec<serde_json::Value>,
commands: serde_json::Value,
@ -4142,6 +4191,13 @@ impl SwarmTriageOutput {
service_execution_missing_check_count: report.service_execution_missing_check_count,
service_execution_failed_check_rows: report.service_execution_failed_check_rows,
service_execution_failed_check_tui_rows: report.service_execution_failed_check_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,
latest_repo_work_overview: report.latest_repo_work_overview_id,
latest_repo_work_gate: report.latest_repo_work_gate,
latest_repo_work_blocker: report.latest_repo_work_blocker,
latest_repo_work_next_safe_move: report.latest_repo_work_next_safe_move,
poked_daemon_count,
pokes,
commands: json!({
@ -4155,6 +4211,7 @@ impl SwarmTriageOutput {
"receipts": "epiphany-verse-query receipt-directory",
"wrapperReceipts": WRAPPER_RECEIPT_DIRECTORY_COMMAND,
"restartPolicies": "epiphany-verse-query restart-policy-directory",
"repoWorkOverview": "epiphany-work overview --workspace <repo> --item <item>",
"wrapperRestartPolicies": WRAPPER_SERVICE_POLICY_DIRECTORY_COMMAND,
"bifrostLedger": "epiphany-verse-query bifrost-ledger",
"wrapperBifrostLedger": WRAPPER_BIFROST_LEDGER_COMMAND,
@ -4339,6 +4396,7 @@ fn swarm_action_rows(
service_lifecycle_attention_rows: &[ReceiptDirectoryRow],
service_execution_failed_check_rows: &[EpiphanyServiceExecutionAuditCheck],
service_execution_runbook_actions: &[ServiceExecutionRunbookAction],
latest_repo_work_overview: Option<&EpiphanyCultMeshRepoWorkOverviewEntry>,
) -> (Vec<SwarmActionRow>, Vec<String>) {
let mut rows = Vec::new();
let mut service_execution_check_counts = BTreeMap::<String, (usize, usize)>::new();
@ -4455,6 +4513,9 @@ fn swarm_action_rows(
private_state_exposed: policy_report.private_state_exposed,
});
}
if let Some(overview) = latest_repo_work_overview {
rows.push(repo_work_overview_action_row(overview));
}
for (index, row) in service_lifecycle_attention_rows.iter().enumerate() {
let (failed_check_count, missing_check_count) = service_execution_check_counts
.get(&row.service_id)
@ -4619,6 +4680,102 @@ fn swarm_action_rows(
(rows, tui_rows)
}
fn repo_work_overview_rows(
latest_repo_work_overview: Option<&EpiphanyCultMeshRepoWorkOverviewEntry>,
) -> (Vec<RepoWorkOverviewRow>, Vec<String>) {
let rows = latest_repo_work_overview
.map(repo_work_overview_row)
.into_iter()
.collect::<Vec<_>>();
let tui_rows = rows
.iter()
.map(repo_work_overview_tui_row)
.collect::<Vec<_>>();
(rows, tui_rows)
}
fn repo_work_overview_row(overview: &EpiphanyCultMeshRepoWorkOverviewEntry) -> RepoWorkOverviewRow {
RepoWorkOverviewRow {
overview_id: overview.overview_id.clone(),
workspace: overview.workspace.clone(),
item: overview.item.clone(),
branch: overview.branch.clone(),
current_gate: overview.current_gate.clone(),
blocker: overview.blocker.clone(),
next_safe_move: overview.next_safe_move.clone(),
changed_path_count: overview.changed_paths.len(),
commit_sha: overview.commit_sha.clone(),
soul_verdict: overview.soul_verdict.clone(),
publication_status: overview.publication_status.clone(),
sync_status: overview.sync_status.clone(),
proof_bundle_ref: overview.proof_bundle_ref.clone(),
private_state_exposed: overview.private_state_exposed,
}
}
fn repo_work_overview_tui_row(row: &RepoWorkOverviewRow) -> String {
format!(
"REPO-WORK | item={} | gate={} | blocker={} | branch={} | commit={} | paths={} | publication={} | sync={} | proof={} | private={}",
row.item,
row.current_gate,
row.blocker,
row.branch,
row.commit_sha,
row.changed_path_count,
row.publication_status,
row.sync_status,
row.proof_bundle_ref,
row.private_state_exposed
)
}
fn repo_work_overview_action_row(
overview: &EpiphanyCultMeshRepoWorkOverviewEntry,
) -> SwarmActionRow {
let status = overview.current_gate.clone();
let command = format!(
"epiphany-work overview --workspace \"{}\" --item \"{}\"",
overview.workspace, overview.item
);
SwarmActionRow {
priority: 35,
family: "repo-work-overview".to_string(),
status,
lifecycle_owner: "Gjallar".to_string(),
hosted_body: "repo-work".to_string(),
action: format!(
"Read latest repo work overview {} for item {}.",
overview.overview_id, overview.item
),
wrapper_mode: "repo-work-overview".to_string(),
wrapper_command: command,
operator_artifact_ref: overview.proof_bundle_ref.clone(),
operator_artifact_status: if overview.proof_bundle_ref == "none" {
"none".to_string()
} else {
"external-ref".to_string()
},
operator_artifact_sha256: "none".to_string(),
operator_artifact_execution_command: "none".to_string(),
operator_aftercare_command: "none".to_string(),
completion_audit_wrapper_mode: "none".to_string(),
completion_audit_wrapper_command: "none".to_string(),
authority_gate: "repo.work.overview".to_string(),
effect_class: "repo-work-readback".to_string(),
mutates_state: false,
requires_elevated_authority: false,
service_execution_failed_check_count: 0,
service_execution_missing_check_count: 0,
service_id: "none".to_string(),
service_route: "none".to_string(),
reason: format!(
"Latest repo work item gate={} blocker={} next={}",
overview.current_gate, overview.blocker, overview.next_safe_move
),
private_state_exposed: overview.private_state_exposed,
}
}
fn swarm_action_tui_row(row: &SwarmActionRow) -> String {
format!(
"{:03} | {} | {} | {} | {} | owner={} | hostedBody={} | service={} | route={} | command={} | mutates={} | elevated={} | failedChecks={} | missingChecks={} | artifact={} | sha256={} | exec={} | audit={} | aftercare={}",
@ -5189,6 +5346,10 @@ fn load_swarm_overview_report(args: &Args) -> Result<SwarmOverviewReport> {
.iter()
.map(daemon_tool_directory_tui_row)
.collect::<Vec<_>>();
let latest_repo_work_overview =
load_latest_epiphany_cultmesh_repo_work_overview(&args.store, args.runtime_id.clone())?;
let (repo_work_overview_rows, repo_work_overview_tui_rows) =
repo_work_overview_rows(latest_repo_work_overview.as_ref());
let (swarm_action_rows, swarm_action_tui_rows) = swarm_action_rows(
&liveness_status,
&tool_host_attention_rows,
@ -5196,6 +5357,7 @@ fn load_swarm_overview_report(args: &Args) -> Result<SwarmOverviewReport> {
&service_lifecycle_attention_rows,
&service_execution_failed_check_rows,
&service_execution_runbook_actions,
latest_repo_work_overview.as_ref(),
);
let private_state_exposed = daemon_report
.rows
@ -5203,10 +5365,25 @@ fn load_swarm_overview_report(args: &Args) -> Result<SwarmOverviewReport> {
.any(|row| row.private_state_exposed)
|| tool_report.rows.iter().any(|row| row.private_state_exposed)
|| policy_report.private_state_exposed
|| latest_repo_work_overview
.as_ref()
.is_some_and(|overview| overview.private_state_exposed)
|| service_execution_private_state_exposed
|| service_lifecycle_rows
.iter()
.any(|row| row.private_state_exposed);
let latest_repo_work_overview_id = latest_repo_work_overview
.as_ref()
.map(|overview| overview.overview_id.clone());
let latest_repo_work_gate = latest_repo_work_overview
.as_ref()
.map(|overview| overview.current_gate.clone());
let latest_repo_work_blocker = latest_repo_work_overview
.as_ref()
.map(|overview| overview.blocker.clone());
let latest_repo_work_next_safe_move = latest_repo_work_overview
.as_ref()
.map(|overview| overview.next_safe_move.clone());
Ok(SwarmOverviewReport {
status,
liveness_status,
@ -5229,6 +5406,12 @@ fn load_swarm_overview_report(args: &Args) -> Result<SwarmOverviewReport> {
service_execution_missing_check_count,
service_execution_failed_check_rows,
service_execution_failed_check_tui_rows,
repo_work_overview_rows,
repo_work_overview_tui_rows,
latest_repo_work_overview_id,
latest_repo_work_gate,
latest_repo_work_blocker,
latest_repo_work_next_safe_move,
topology_report,
daemon_report,
surface_report,

View file

@ -646,6 +646,17 @@ read `latestRepoWorkOverview=repo-work-overview-verse-overview-request`,
`latestRepoWorkBlocker=bifrost-publication-missing`, saw seven Eve surfaces,
and reported `privateStateExposed=false`.
The first Gjallar projection smoke proved the latest-key global sight path:
`epiphany-verse-query gjallar --store <repo>\.epiphany\local-verse.ccmp
--runtime-id repo-swarm-local` read the same typed overview and emitted
`repoWorkOverviewCount=1`, latest gate/blocker fields, a compact `REPO-WORK`
TUI row, and a priority 35 `repo-work-overview` action row with
`owner=Gjallar`, `hostedBody=repo-work`, `authorityGate=repo.work.overview`,
`mutatesState=false`, `requiresElevatedAuthority=false`, and
`privateStateExposed=false`. Proof artifact:
`.epiphany-smoke\gjallar-repo-work-overview-20260620-011119`. This is still
latest-key sight, not multi-item queue enumeration.
## Migration Implication
The next migration plan must treat autonomous branch-local work as a required
@ -882,10 +893,11 @@ Required organs before MVP:
- Closure depth: deterministic Soul/Modeling/Mind closure exists for Hands
commits; richer model-authored Soul/Modeling review remains to replace the
current local verification rite where appropriate.
- Repo work projection: local `epiphany-work overview` proof bundles and typed
`epiphany.cultmesh.repo_work_overview.v0` latest-key projection exist;
remaining work is richer Gjallar/Eve presentation of queues and multiple
work items for Personas and peer bodies.
- Repo work projection: local `epiphany-work overview` proof bundles, typed
`epiphany.cultmesh.repo_work_overview.v0` latest-key projection, and Gjallar
latest-key `repo-work-overview` action/readback rows exist. Remaining work is
typed history/queue enumeration plus richer Eve presentation of multiple work
items for Personas and peer bodies.
- Proof bundle depth: maintainers and future agents can inspect local
operator-safe receipt chains, commit refs, verification verdicts, map
admission, Bifrost/GitHub refs, credit refs, and sync state; remaining work is

View file

@ -104,6 +104,7 @@ remembers doctrine; the branch remembers the blade.
- `notes/epiphany-swarm-readiness-plan.md` is the current live-fire direction gate. The local runner proves startup/status/coordinator wiring; it does not authorize unattended swarm operation. Carry VoidBot's lessons forward: one CTB-style initiative scheduler, typed pause/brake, active-turn freeze, cooldown after completion, stale active-turn recovery receipts, parent-side speech eligibility, memory lifecycle phases, and typed operation proposals instead of prompt-owned governance. `epiphany-verse-query swarm-brake --brake-status engaged|released` can now write the local Verse brake document, and `tools/epiphany_local_run.ps1` refuses live `plan`/`run`/`mvp` modes when that brake is engaged while keeping `status` readable. `epiphany-mvp-coordinator` also checks `--local-verse-store` before app-server startup, and `epiphany-heartbeat-store` guards tick/pump/heat/queue-mention/routine when passed `--local-verse-store`. Daemon tool invocation, daemon lifecycle poke, and `epiphany-daemon-supervisor` restart/tick/serve/service-plan/service-launch/service-runbook/windows-service-install/windows-service-status/windows-service-reconcile/windows-service-execution-readiness/start/stop attempts now fail closed under a matching engaged brake; supervisor restart now has durable per-daemon policy with cooldown/backoff, explicit scheduled tick pulses, latest scheduler receipts, typed service lifecycle plan/launch/runbook/install/status/reconcile/readiness/start/stop receipts, and local operator wrapper modes that write runbook/install/status/reconcile/readiness/control-plan/execution artifacts plus operator run receipts. The installed-service read path, read-only service-policy reconciliation path, execution-readiness path, non-mutating start/stop control-plan path, and non-elevated execution refusal path have been proved against real Windows `EventLog` service-manager state or safe missing-service targets through local Verse receipts, including explicit wrapper install/start/stop execution modes. The next cut is actual elevated install/start/stop execution proof under operator authority.
- `notes/epiphany-repo-swarm-mvp-contract.md` is the repo-swarm MVP authority map and migration plan. It states the live thirteen-front-door chain from `epiphany-repo init` through `epiphany-work derive-plan`, `close`, `overview`, `tick`, `publish`, and `sync`, documents the operator-safe proof receipts already proved with `privateStateExposed=false`, and names the remaining MVP organs: model-authored Persona-to-plan depth, richer Gjallar/Eve presentation over repo work overview rows, optional execute-to-close handoff, richer published proof bundles, and richer model-authored closure. Autonomous branch-local work inside the owned repo Body is in scope and desired; Bifrost gates publication/merge/escalation, Idunn owns daemon lifecycle, and `epiphany-work tick` may only advance one safe receipt-backed branch-local step per pulse before stopping at closure or publication gates. `epiphany-work derive-plan` now consumes accepted Persona/Bifrost pressure and writes an Imagination/Self action plan in deterministic `append-worklog` quarantine mode with `operatorAuthoredShellDetails=false`; disposable smoke proved accept -> derive-plan -> run -> adopt -> execute -> close, changed only `EPIPHANY_WORKLOG.md`, ended `closed:passed`, and reported no private-state exposure. `epiphany-work overview` now reads the repo work receipt chain and writes an Eyes/Gjallar-owned sight/proof bundle with current gate, blocker, next safe action, branch, changed paths, commit SHA, Soul verdict, compact rows, and private-state seal; it also mirrors a typed `epiphany.cultmesh.repo_work_overview.v0` document into the repo-local Verse when a local Verse store is known. Disposable smokes proved pre-plan `awaiting-plan`/`plan-receipt-missing`, post-close `awaiting-publication`/`bifrost-publication-missing`, and latest-key CultMesh readback through `epiphany-verse-query smoke` as `latestRepoWorkOverview=repo-work-overview-verse-overview-request`, `latestRepoWorkGate=awaiting-publication`, `latestRepoWorkBlocker=bifrost-publication-missing`, with no private-state exposure. The tick pulse reads the repo-local CultMesh swarm brake and writes `refused-by-swarm-brake` without creating run/adopt/execute receipts when the brake is engaged. It also writes active-turn and last-completed scheduler receipts, refuses live duplicate pulses as `refused-active-turn`, refuses explicit completion-anchored cooldown as `refused-by-cooldown`, clears stale active markers after `--active-timeout-seconds`, and records `physiology.recoveredActiveTurn.recovered=true` when recovery proceeds. `epiphany-work serve` wraps that tick artery in Self-owned cadence: bounded `--max-iterations` proof mode writes `work-scheduler-serve-<item>.json`, unbounded service mode relies on per-pulse tick receipts, and unbounded zero-second polling is refused. `epiphany-work close` consumes branch-local execute receipts, verifies the Hands commit, writes Soul verdict plus Modeling summary plus Mind gateway/state-commit receipts, and seals `work-close-<item>.json` without granting publication, merge, service lifecycle, cross-repo mutation, or private-state exposure. `epiphany-work publish --closure-receipt` can consume the closure's Soul/Mind ids, while tick no-ops once closure exists before Bifrost publication authority.
- 2026-06-20: The same repo-swarm note now carries the explicit migration thesis, MVP status board, authority matrix, local CultMesh tool availability doctrine, and upstream-main sync doctrine. Use that note when answering "are we headed toward a functional swarm?" The answer is yes, but only if the remaining cuts preserve the typed organ ownership: Persona is the mouth, Imagination plans, Self schedules, Hands acts, Soul verifies, Modeling maps, Mind admits, Gjallar sees, Odin discovers, Idunn keeps daemon physiology alive, Bifrost publishes and credits, and Eve/CultUI renders without becoming truth.
- 2026-06-20: Gjallar/swarm-overview now exposes the latest repo-work overview as first-class compact sight. `SwarmOverviewOutput` and `SwarmTriageOutput` include `repoWorkOverviewCount`, `repoWorkOverviewRows`, `repoWorkOverviewTuiRows`, `latestRepoWorkOverview`, `latestRepoWorkGate`, `latestRepoWorkBlocker`, and `latestRepoWorkNextSafeMove`. The shared `swarmActionRows` queue also 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. Disposable proof `.epiphany-smoke\gjallar-repo-work-overview-20260620-011119` created a fresh repo, ran `init -> online -> accept -> overview -> gjallar`, and read `latestRepoWorkOverview=repo-work-overview-gjallar-request`, gate `awaiting-plan`, blocker `plan-receipt-missing`, one compact `REPO-WORK` row, non-mutating/non-elevated action row, and `privateStateExposed=false`. This completes latest-key presentation, not multiple-work-item queue enumeration; build a typed history/queue loader next.
- `service-execution-runbook` makes that next cut repeatable: it generates the exact elevated wrapper command sequence without mutating the service manager, continues after per-step failure to preserve more receipts, runs `service-execution-audit` in `finally`, exits nonzero if any step failed, and seals a typed runbook lifecycle receipt. Run the generated artifact only with explicit operator authority.
- `service-execution-audit` is the non-mutating acceptance proof after the elevated rite: it reports `complete` only when typed lifecycle receipts prove the runbook witness plus expected elevated chain, and otherwise reports the missing/failed sealed checks.
- `service-tick` is the non-elevated scheduler pulse proof: it writes the latest daemon scheduler receipt through durable policy ownership and local wrapper receipts.

Binary file not shown.

View file

@ -89,6 +89,7 @@ active_subgoals:
- Preserve the Ghostlight-derived heartbeat initiative seam: every lane, including coordinator/Self and Persona, has a organ-state record and competes for heartbeat slots through readiness/reaction timing; initiative heat can raise or cool global, group, arena, role, and agent tempo through typed heartbeat policy; active thinking freezes initiative until completion, so heat never queues a lane already mid-turn; idle winners ruminate instead of inventing project work, and sleep windows distill the accumulated thought pressure into reviewed self-memory or doctrine.
- 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 authority correction and migration plan for repo-swarm autonomy. Autonomous branch-local work inside an Epiphany-owned repo Body is in scope and desired; the safety boundary is typed authority, branch containment, interruptibility, receipts, private-state sealing, and Bifrost-gated publication/merge/escalation, not asking a human before every local edit. Thirteen native repo-swarm front doors are live and documented there: `epiphany-repo init`, `epiphany-swarm online`, `epiphany-work accept`, `epiphany-work derive-plan`, `epiphany-work plan`, `epiphany-work run`, `epiphany-work adopt --from-plan`, `epiphany-work execute --from-plan`, `epiphany-work close`, `epiphany-work overview`, `epiphany-work tick`, `epiphany-work publish`, and `epiphany-work sync`. Fresh-repo smokes proved the chain with `privateStateExposed=false`, including deterministic Persona/Bifrost pressure-to-plan derivation (`append-worklog`, `operatorAuthoredShellDetails=false`) into `EPIPHANY_WORKLOG.md`, plan-backed branch-local commit creation, a Self-owned tick pulse that advances `run-from-plan -> adopt-from-plan -> execute-from-plan` then no-ops before closure/publication gates, local CultMesh swarm-brake refusal that writes `refused-by-swarm-brake` without creating a run/adopt/execute receipt, active-turn refusal through `work-tick-active-<item>.json`, explicit completion-anchored cooldown refusal through `work-tick-last-<item>.json`, stale active-turn recovery that records `physiology.recoveredActiveTurn.recovered=true`, Self-owned `epiphany-work serve` cadence that writes `work-scheduler-serve-<item>.json`, bounded serve proof `advanced:run-from-plan -> refused-by-cooldown:none` without adoption, unbounded zero-interval refusal, deterministic `epiphany-work close` proof that consumes execute receipts, verifies the Hands commit, writes Soul verdict plus Modeling summary plus Mind gateway/state-commit receipts, local `epiphany-work overview` proof bundle that reports pre-plan `awaiting-plan`/`plan-receipt-missing` and post-close `awaiting-publication`/`bifrost-publication-missing` with branch, commit, changed paths, Soul verdict, compact rows, and private seal, typed local Verse projection as `epiphany.cultmesh.repo_work_overview.v0` with latest-key readback through `epiphany-verse-query smoke`, `publish --closure-receipt` consumption of the close receipt's Soul/Mind refs, post-publication tick `noop:none`, and upstream-main ancestry proof after explicit merge receipt. Remaining MVP organs are model-authored Persona-to-plan depth for richer actions, richer Gjallar/Eve presentation of repo work queues and multiple work items, optional execute-to-close scheduler handoff, richer published proof bundles, and richer model-authored closure; the scheduler may advance only one safe receipt-backed branch-local step per pulse and must not publish, merge, mutate services, cross repo boundaries, expose private state, or impersonate Idunn.
- Gjallar/swarm-overview now projects the latest typed repo-work overview into the compact global sight report. `epiphany-verse-query gjallar` reads `epiphany.cultmesh.repo_work_overview.v0` from local Verse, emits `latestRepoWorkOverview`, `latestRepoWorkGate`, `latestRepoWorkBlocker`, `latestRepoWorkNextSafeMove`, a `repoWorkOverviewRows`/TUI row, and a priority 35 non-mutating `repo-work-overview` action row with `owner=Gjallar`, `hostedBody=repo-work`, `authorityGate=repo.work.overview`, `mutatesState=false`, `requiresElevatedAuthority=false`, proof-bundle ref, current gate/blocker/next-safe-move, and `privateStateExposed=false`. Disposable proof `.epiphany-smoke\gjallar-repo-work-overview-20260620-011119` showed item `gjallar-request`, gate `awaiting-plan`, blocker `plan-receipt-missing`, `repoWorkOverviewCount=1`, compact `REPO-WORK` row, and no private-state exposure. This is latest-key sight only; multiple-work-item enumeration still needs a typed history/queue loader instead of pretending the latest mirror is a queue.
- 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.
- Grow the VoidBot repo-Persona pattern into Epiphany's product direction: each Epiphany owns one or more repos, has one or more Personas, and exposes project-native conversation through Aquarium, Discord, voice/WebRTC, stream surfaces, CLI, and CultNet clients so humans can talk to projects instead of pre-authoring complete implementation briefs. Persona is special because Imagination acts as Projector, turning typed state into narrative context before the Persona thinks, and Mind acts as Interpreter, turning natural Persona output into reviewed state/side-effect intents after the Persona thinks.
@ -633,4 +634,4 @@ 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.
next_action: Continue repo-swarm MVP work from the documented thirteen-front-door chain. Next build richer Gjallar/Eve presentation over the typed `epiphany.cultmesh.repo_work_overview.v0` local Verse document: compact queue rows, multiple work-item sight, and Persona/peer-readable current gate/blocker/next-action summaries without opening raw worker thought. Preserve Idunn service lifecycle surfaces and existing CultMesh/Odin/Eve tool directories; service install/start execution still requires explicit elevated operator authority.
next_action: Continue repo-swarm MVP work from the documented thirteen-front-door chain. Latest-key Gjallar repo-work sight is live; next build typed repo-work history/queue enumeration over `epiphany.cultmesh.repo_work_overview.v0` so Gjallar/Eve can show multiple work items instead of only the latest mirror, then lower that queue into Persona/peer-readable current gate/blocker/next-action summaries without opening raw worker thought. Preserve Idunn service lifecycle surfaces and existing CultMesh/Odin/Eve tool directories; service install/start execution still requires explicit elevated operator authority.