From e30f91167f4f9f54929aa2bba8c1dba02209e1e6 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sun, 12 Jul 2026 22:09:38 +0100 Subject: [PATCH] Delete writerless operator status schema --- epiphany-core/src/cultmesh_integration.rs | 124 +----------------- epiphany-core/src/lib.rs | 9 -- epiphany-core/src/prompt_context.rs | 8 -- epiphany-core/src/runtime_spine.rs | 39 ------ ...onceptual-substitution-audit-2026-07-12.md | 10 +- notes/epiphany-current-algorithmic-map.md | 9 +- notes/fresh-workspace-handoff.md | 9 +- ...phany.cultmesh.operator-status.schema.json | 66 ---------- schemas/cultnet/index.json | 11 -- state/ledgers.msgpack | Bin 439432 -> 439822 bytes state/map.yaml | 11 +- 11 files changed, 20 insertions(+), 276 deletions(-) delete mode 100644 schemas/cultnet/epiphany.cultmesh.operator-status.schema.json diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index 2e74f860..cade43bd 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -22,10 +22,6 @@ use std::path::Path; pub const EPIPHANY_CULTMESH_STATUS_TYPE: &str = "epiphany.cultmesh.status"; pub const EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION: &str = "epiphany.cultmesh.status.v0"; pub const EPIPHANY_CULTMESH_STATUS_KEY: &str = "epiphany-local/status"; -pub const EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE: &str = "epiphany.cultmesh.operator_status"; -pub const EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION: &str = - "epiphany.cultmesh.operator_status.v0"; -pub const EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY: &str = "epiphany-local/operator-status"; pub const EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE: &str = "epiphany.cultmesh.operator_snapshot"; pub const EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION: &str = "epiphany.cultmesh.operator_snapshot.v0"; @@ -296,38 +292,6 @@ pub struct EpiphanyCultMeshStatusEntry { pub verse_tier: String, } -#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] -#[cultcache( - type = "epiphany.cultmesh.operator_status", - schema = "EpiphanyCultMeshOperatorStatusEntry" -)] -pub struct EpiphanyCultMeshOperatorStatusEntry { - #[cultcache(key = 0)] - pub schema_version: String, - #[cultcache(key = 1)] - pub runtime_id: String, - #[cultcache(key = 2)] - pub verse_id: String, - #[cultcache(key = 3)] - pub surface_id: String, - #[cultcache(key = 4)] - pub status: String, - #[cultcache(key = 5)] - pub generated_at_utc: String, - #[cultcache(key = 6)] - pub summary: String, - #[cultcache(key = 7)] - pub codex_bridge_role: String, - #[cultcache(key = 8)] - pub epiphany_authority_role: String, - #[cultcache(key = 9)] - pub prompt_authority: String, - #[cultcache(key = 10)] - pub native_authorities: Vec, - #[cultcache(key = 11)] - pub quarantined_surfaces: Vec, -} - #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] #[cultcache( type = "epiphany.cultmesh.operator_snapshot", @@ -2534,7 +2498,6 @@ pub struct EpiphanyLocalVerseContext { Option, pub latest_imagination_consensus_receipt: Option, - pub operator_status: Option, pub latest_operator_snapshot: Option, pub latest_operator_run_intent: Option, pub latest_operator_run_receipt: Option, @@ -2586,7 +2549,6 @@ pub struct EpiphanyLocalVerseContractSummary { cultmesh_documents!(EpiphanyCultMeshDocuments { EpiphanyCultMeshStatusEntry => EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION, - EpiphanyCultMeshOperatorStatusEntry => EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION, EpiphanyCultMeshOperatorSnapshotEntry => EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION, EpiphanyCultMeshOperatorRunIntentEntry => EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION, EpiphanyCultMeshOperatorRunReceiptEntry => EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION, @@ -2671,66 +2633,6 @@ pub fn load_epiphany_cultmesh_status( node.get(EPIPHANY_CULTMESH_STATUS_KEY) } -#[cfg(test)] -pub fn default_epiphany_cultmesh_operator_status( - runtime_id: impl Into, - generated_at_utc: impl Into, -) -> EpiphanyCultMeshOperatorStatusEntry { - EpiphanyCultMeshOperatorStatusEntry { - schema_version: EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION.to_string(), - runtime_id: runtime_id.into(), - verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(), - surface_id: "epiphany.operator.status".to_string(), - status: "ready".to_string(), - generated_at_utc: generated_at_utc.into(), - summary: - "Epiphany operator status is native typed state; Codex is bridge transport, not policy owner." - .to_string(), - codex_bridge_role: - "relatively vanilla Codex may provide OpenAI auth/model transport, streaming, and Codex-native app-server affordances." - .to_string(), - epiphany_authority_role: - "Epiphany owns state, processes, prompts, scheduler decisions, organ contracts, and mutation law." - .to_string(), - prompt_authority: - "Codex prompt machinery must not inject doctrine, role instructions, state law, or coordinator policy into Epiphany agents." - .to_string(), - native_authorities: vec![ - "CultCache typed documents".to_string(), - "CultMesh local Verse store".to_string(), - "CultNet read/mutation/event contracts".to_string(), - "Epiphany organ receipt gates".to_string(), - ], - quarantined_surfaces: vec![ - "Rider bridge".to_string(), - "Unity bridge".to_string(), - ], - } -} - -#[cfg(test)] -pub fn write_epiphany_cultmesh_operator_status( - store_path: impl AsRef, - status: EpiphanyCultMeshOperatorStatusEntry, -) -> Result { - let mut node = open_epiphany_cultmesh_node(&store_path, status.runtime_id.clone())?; - let written = node.put(EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY, &status)?; - node.flush()?; - Ok(written) -} - -pub fn load_epiphany_cultmesh_operator_status( - store_path: impl AsRef, - runtime_id: impl Into, -) -> Result> { - let store_path = store_path.as_ref(); - if !store_path.exists() { - return Ok(None); - } - let node = open_epiphany_cultmesh_node(store_path, runtime_id)?; - node.get(EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY) -} - pub fn epiphany_cultmesh_operator_snapshot_from_status_json( runtime_id: impl Into, snapshot_id: impl Into, @@ -2743,7 +2645,7 @@ pub fn epiphany_cultmesh_operator_snapshot_from_status_json( let state_status = pointer_text(status_json, "/scene/scene/stateStatus", "unknown"); let crrc_action = pointer_text(status_json, "/crrc/recommendation/action", "unknown"); let reorient_action = pointer_text(status_json, "/reorient/decision/action", "unknown"); - let operator_status = if state_status == "missing" || crrc_action == "regatherManually" { + let snapshot_status = if state_status == "missing" || crrc_action == "regatherManually" { "needs-regather" } else { "ready" @@ -2762,7 +2664,7 @@ pub fn epiphany_cultmesh_operator_snapshot_from_status_json( source_mode: source_mode.into(), source_path, thread_id: pointer_text(status_json, "/threadId", "missing"), - status: operator_status.to_string(), + status: snapshot_status.to_string(), state_status, coordinator_action: pointer_text(status_json, "/coordinator/action", "none"), crrc_action, @@ -5983,7 +5885,6 @@ pub fn query_epiphany_local_verse_context( .get(EPIPHANY_CULTMESH_BIFROST_COLLABORATION_FEEDBACK_LATEST_KEY)?, latest_imagination_consensus_receipt: node .get(EPIPHANY_CULTMESH_IMAGINATION_CONSENSUS_RECEIPT_LATEST_KEY)?, - operator_status: node.get(EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY)?, latest_operator_snapshot: node.get(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY)?, latest_operator_run_intent: node.get(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY)?, latest_operator_run_receipt: node.get(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY)?, @@ -7233,26 +7134,6 @@ mod tests { Ok(()) } - #[test] - fn operator_status_round_trips_as_native_cultmesh_document() -> Result<()> { - let temp = tempfile::tempdir()?; - let store = temp.path().join("epiphany-operator-status.ccmp"); - let status = - default_epiphany_cultmesh_operator_status("epiphany-test", "2026-05-27T00:00:00Z"); - - write_epiphany_cultmesh_operator_status(&store, status.clone())?; - let loaded = load_epiphany_cultmesh_operator_status(&store, "epiphany-test")?; - - assert_eq!(loaded, Some(status)); - let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?; - assert!( - node.documents() - .binding(EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE) - .is_some() - ); - Ok(()) - } - #[test] fn operator_snapshot_distills_status_json_into_typed_cultmesh_document() -> Result<()> { let temp = tempfile::tempdir()?; @@ -9323,7 +9204,6 @@ mod tests { assert!(context.odin_advertisements.is_empty()); assert!(context.eve_surface_states.is_empty()); assert!(context.daemon_tool_capabilities.is_empty()); - assert!(context.operator_status.is_none()); assert!( context .contract_summaries diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 23d3ae53..e0089677 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -270,9 +270,6 @@ pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY; pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE; -pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY; -pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION; -pub use cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_LATEST_KEY; pub use cultmesh_integration::EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_TYPE; @@ -350,7 +347,6 @@ pub use cultmesh_integration::EpiphanyCultMeshOdinAdvertisementEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorRunIntentEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorRunReceiptEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorSnapshotEntry; -pub use cultmesh_integration::EpiphanyCultMeshOperatorStatusEntry; pub use cultmesh_integration::EpiphanyCultMeshPersonaSpeechAuditEntry; pub use cultmesh_integration::EpiphanyCultMeshRepoWorkMapEntry; pub use cultmesh_integration::EpiphanyCultMeshRepoWorkOverviewEntry; @@ -370,8 +366,6 @@ pub use cultmesh_integration::EpiphanyLocalVerseContractSummary; pub use cultmesh_integration::EpiphanyLocalVerseWorkLoopSummary; pub use cultmesh_integration::EpiphanyServiceExecutionAuditCheck; pub use cultmesh_integration::EpiphanyServiceExecutionAuditReport; -#[cfg(test)] -pub use cultmesh_integration::default_epiphany_cultmesh_operator_status; pub use cultmesh_integration::default_epiphany_cultmesh_swarm_brake; pub use cultmesh_integration::epiphany_cluster_service_execution_audit_report; pub use cultmesh_integration::epiphany_cultmesh_agent_state_soa_summary_from_entry; @@ -426,7 +420,6 @@ pub use cultmesh_integration::load_epiphany_cultmesh_idunn_deployment_receipt; pub use cultmesh_integration::load_epiphany_cultmesh_managed_service_policies; pub use cultmesh_integration::load_epiphany_cultmesh_managed_service_policy; pub use cultmesh_integration::load_epiphany_cultmesh_operator_snapshot; -pub use cultmesh_integration::load_epiphany_cultmesh_operator_status; pub use cultmesh_integration::load_epiphany_cultmesh_repo_work_map_entries; pub use cultmesh_integration::load_epiphany_cultmesh_repo_work_overviews; pub use cultmesh_integration::load_epiphany_cultmesh_repo_work_public_proofs; @@ -512,8 +505,6 @@ pub use cultmesh_integration::write_epiphany_cultmesh_mind_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_operator_run_intent; pub use cultmesh_integration::write_epiphany_cultmesh_operator_run_receipt; pub use cultmesh_integration::write_epiphany_cultmesh_operator_snapshot; -#[cfg(test)] -pub use cultmesh_integration::write_epiphany_cultmesh_operator_status; pub use cultmesh_integration::write_epiphany_cultmesh_persona_speech_audit; pub use cultmesh_integration::write_epiphany_cultmesh_repo_work_map_entry; pub use cultmesh_integration::write_epiphany_cultmesh_repo_work_overview; diff --git a/epiphany-core/src/prompt_context.rs b/epiphany-core/src/prompt_context.rs index 28972081..0033a09e 100644 --- a/epiphany-core/src/prompt_context.rs +++ b/epiphany-core/src/prompt_context.rs @@ -246,14 +246,6 @@ pub fn render_epiphany_prompt_context(input: &EpiphanyPromptContextInput) -> Str } } - if let Some(status) = input.local_verse.operator_status.as_ref() { - lines.push(format!( - "- Operator status `{}`: {}", - status.status, - compact_line(&status.summary) - )); - } - if let Some(summary) = input.local_verse.latest_work_loop_summary.as_ref() { lines.push("## Work Loop Receipt Digest".to_string()); lines.push(format!( diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index 256b72e9..508afb58 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -8,8 +8,6 @@ use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_V use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE; -use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION; -use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE; use crate::eyes_gateway::EYES_EVIDENCE_PACKET_SCHEMA_VERSION; use crate::eyes_gateway::EYES_EVIDENCE_PACKET_TYPE; use crate::eyes_gateway::EYES_EVIDENCE_REFUSAL_RECEIPT_SCHEMA_VERSION; @@ -3528,18 +3526,6 @@ fn epiphany_mutation_contracts() -> Vec { "The unified memory graph is typed durable state; Qdrant embeddings are rebuildable cache, not canonical memory.", ], ), - mutation_contract( - EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE, - EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION, - vec![CultNetDocumentOperation::Snapshot], - CultNetMutationAuthority::ReadOnly, - vec![], - vec![], - vec![ - "Native operator status is a CultMesh document; Codex app-server status is bridge/display compatibility.", - "This surface names the Codex bridge role, Epiphany authority role, prompt-authority boundary, and quarantined optional bridges.", - ], - ), mutation_contract( EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE, EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION, @@ -4869,26 +4855,6 @@ mod tests { .iter() .any(|item| item == "epiphany.persona_bubble.v0")) ); - let operator_status_contract = contracts - .iter() - .find(|contract| { - contract.document_type == EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE - }) - .expect("operator status should advertise a read-only CultMesh document"); - assert_eq!( - operator_status_contract.authority, - CultNetMutationAuthority::ReadOnly - ); - assert!( - operator_status_contract - .notes - .as_ref() - .is_some_and(|notes| { - notes - .iter() - .any(|note| note.contains("Codex app-server status is bridge")) - }) - ); let operator_snapshot_contract = contracts .iter() .find(|contract| { @@ -5123,11 +5089,6 @@ mod tests { schema.document_type.as_deref() == Some(THREAD_STATE_TYPE) && schema.schema_version.as_deref() == Some(THREAD_STATE_SCHEMA_VERSION) })); - assert!(schemas.iter().any(|schema| { - schema.document_type.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE) - && schema.schema_version.as_deref() - == Some(EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION) - })); assert!(schemas.iter().any(|schema| { schema.document_type.as_deref() == Some(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE) && schema.schema_version.as_deref() diff --git a/notes/conceptual-substitution-audit-2026-07-12.md b/notes/conceptual-substitution-audit-2026-07-12.md index 42f9872f..a4faee9e 100644 --- a/notes/conceptual-substitution-audit-2026-07-12.md +++ b/notes/conceptual-substitution-audit-2026-07-12.md @@ -198,11 +198,11 @@ operator observation that no observer had produced. Bootstrap now writes declaration/initialization state only and leaves operator status absent. The follow-up audit showed `epiphany-cultmesh-status write` was not an observer: it had no production caller and hard-coded `status=ready` plus -doctrine fields from a template. The shipped binary is deleted, and its default -constructor/writer are test-only. The fixed CultMesh smoke no longer fabricates -operator status; it retains its separate source-JSON-derived operator snapshot -contract proof. Production keeps the typed operator-status schema and a -filesystem-pure reader for future genuine observed ingest. +doctrine fields from a template. The shipped binary and the entire writerless +operator-status schema family are deleted. Keeping a catalog entry, context +slot, prompt projection, and reader for a hypothetical future observer made +absence look like implemented authority. The fixed CultMesh smoke retains the +real contract: an operator snapshot distilled from a named source artifact. ## Agent-state projection body boundary diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md index d85bc173..19e5ddbb 100644 --- a/notes/epiphany-current-algorithmic-map.md +++ b/notes/epiphany-current-algorithmic-map.md @@ -83,7 +83,7 @@ - `epiphany-verse-query smoke` owns synthetic contract fixtures only. - Its only writable body is `.epiphany-smoke/verse-query-default/local-verse.ccmp` with runtime `verse-query-default-smoke`. - Generic local Verse bootstrap owns policy, declared topology, initial brake, - organ contracts, and operator status only. It does not publish Odin provider + and organ contracts only. It does not publish Odin provider advertisements, Eve surfaces, or daemon-hosted tools. Those families require provider publication; discovery preserves their absence. - The generic Verse query CLI has no provider-advertisement preview or Odin @@ -123,10 +123,9 @@ persisted loaders; only the daemon-ID-bounded publisher may lower templates into provider-owned documents. - Generic bootstrap owns declarations and initial control state, not operator - observation. The template-based operator-status writer binary is deleted and - its constructor/writer are test-only. Production retains the typed schema and - a filesystem-pure reader for genuinely observed future ingest; operator - snapshots remain source-artifact-derived documents. + observation. The template-based operator-status writer and its writerless + schema/context/prompt/reader family are deleted. Operator snapshots remain + source-artifact-derived documents. - Agent-state SoA sync requires an existing bootstrapped Verse before mirroring the persisted agent store. SoA report is filesystem-pure on a missing store. Wrapper mode `agent-state-soa` explicitly composes sync then report; the diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 9d74cf7f..cb5ca178 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -23,7 +23,7 @@ The confirmed conceptual substitutions have been cut: tools; unknown daemon identities are refused before writes. - cluster daemons do not bootstrap or query the full Verse. Missing persisted topology is a pre-write refusal; explicit operator bootstrap owns shared - policy, topology, contracts, brake initialization, and operator status. + policy, topology, contracts, and brake initialization. - daemon-supervisor production commands likewise require persisted bootstrap and cannot create shared state. Its two audit-smoke fixture initializers are hard-confined beneath `.epiphany-smoke`. @@ -42,10 +42,9 @@ The confirmed conceptual substitutions have been cut: - topology-derived provider builders are private, explicitly named templates. Consumers can load persisted provider documents but cannot request seven plausible advertisements/surfaces/tools from topology. -- bootstrap no longer writes default operator status. Only the dedicated - operator-status writer was then found to be a dead `ready` template and - deleted. Its constructor/writer are test-only; production retains typed - reading for genuine observed ingest and source-derived operator snapshots. +- bootstrap no longer writes default operator status. The dedicated writer was + a dead `ready` template, so the writer and its now-ownerless schema/context/ + prompt/reader family are deleted. Source-derived operator snapshots remain. - agent-state SoA sync requires bootstrap; report preserves missing filesystem state. The wrapper explicitly composes sync then report rather than hiding a refresh inside readback. diff --git a/schemas/cultnet/epiphany.cultmesh.operator-status.schema.json b/schemas/cultnet/epiphany.cultmesh.operator-status.schema.json deleted file mode 100644 index a7daf441..00000000 --- a/schemas/cultnet/epiphany.cultmesh.operator-status.schema.json +++ /dev/null @@ -1,66 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "$id": "https://gamecult.dev/epiphany/cultnet/epiphany.cultmesh.operator-status.schema.json", - "title": "Epiphany CultMesh Operator Status", - "description": "Native operator-status CultCache tuple naming the Codex bridge role, Epiphany authority role, prompt boundary, and quarantined optional bridge surfaces.", - "type": "array", - "minItems": 12, - "maxItems": 12, - "items": [ - { - "title": "schemaVersion", - "type": "string", - "const": "epiphany.cultmesh.operator_status.v0" - }, - { - "title": "runtimeId", - "type": "string" - }, - { - "title": "verseId", - "type": "string" - }, - { - "title": "surfaceId", - "type": "string" - }, - { - "title": "status", - "type": "string" - }, - { - "title": "generatedAtUtc", - "type": "string" - }, - { - "title": "summary", - "type": "string" - }, - { - "title": "codexBridgeRole", - "type": "string" - }, - { - "title": "epiphanyAuthorityRole", - "type": "string" - }, - { - "title": "promptAuthority", - "type": "string" - }, - { - "title": "nativeAuthorities", - "type": "array", - "items": { - "type": "string" - } - }, - { - "title": "quarantinedSurfaces", - "type": "array", - "items": { - "type": "string" - } - } - ] -} diff --git a/schemas/cultnet/index.json b/schemas/cultnet/index.json index 83f25831..1da5d8dd 100644 --- a/schemas/cultnet/index.json +++ b/schemas/cultnet/index.json @@ -298,17 +298,6 @@ "title": "Epiphany Memory Graph", "path": "epiphany.memory-graph.schema.json" }, - { - "schemaId": "https://gamecult.dev/epiphany/cultnet/epiphany.cultmesh.operator-status.schema.json", - "kind": "document_payload", - "wireContracts": [ - "cultnet.schema.v0" - ], - "schemaVersion": "epiphany.cultmesh.operator_status.v0", - "documentType": "epiphany.cultmesh.operator_status", - "title": "Epiphany CultMesh Operator Status", - "path": "epiphany.cultmesh.operator-status.schema.json" - }, { "schemaId": "https://gamecult.dev/epiphany/cultnet/epiphany.cultmesh.operator-snapshot.schema.json", "kind": "document_payload", diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index ac40a0960aea40f922383e6d1f2c54b9b61e4c7a..1ea5091da47124c4ca57610f4949b0d8a60a44b1 100644 GIT binary patch delta 348 zcmW-cze)o^5XQYTUSVNlqX~owwwIt5V$y0WRt5=Jtb23Zn%muTXD%_dg;sXQJ%Ejf zg`(ga_z)KMqMa|`CdJ3cFn_+^+F;H$fhQe80@Z2s?va-exmWGwa#h??C6hkJ6^DpN=gJm;bazrFbO0oO~F4Z$Gv~)?tNnb delta 56 zcmeBsBh~RzYJ(&rmw}a`anvyew#})Vl^F{e8HJjsGPO@-VgzCk%?!jWK+L**Diho1 FjQ|K$5)%Lb diff --git a/state/map.yaml b/state/map.yaml index 1dca584c..c075c06b 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -70,7 +70,7 @@ data_flow: - move historical proof to git, commits, smoke artifacts, or distilled evidence rather than plan prose active_subgoals: - - Use `notes/conceptual-substitution-audit-2026-07-12.md` plus `notes/receipt-writer-provenance-audit-2026-07-12.md` as the current authority-corrosion maps. Snapshot promotion, synthetic smoke escape, unbound operator completion, hidden service execution flags, provider/bootstrap collapse, central/all-provider publication, production-side implicit bootstrap, orphaned external response authority, bulk readiness authority, public topology-derived provider builders, bootstrap/template-authored operator observation, and SoA projection body creation are cut. Provider responses/readiness/operator status without observers are test-only or deleted; templates are private; query mutations require the body; missing reads preserve filesystem absence. Next audit remaining projections, caches, schedulers, adapters, and non-receipt smokes for borrowed authority or path escape. + - Use `notes/conceptual-substitution-audit-2026-07-12.md` plus `notes/receipt-writer-provenance-audit-2026-07-12.md` as the current authority-corrosion maps. Snapshot promotion, synthetic smoke escape, unbound operator completion, hidden service execution flags, provider/bootstrap collapse, central/all-provider publication, production-side implicit bootstrap, orphaned external response authority, bulk readiness authority, public topology-derived provider builders, bootstrap/template-authored operator observation, writerless operator-status schema authority, and SoA projection body creation are cut. Provider responses and readiness without observers are test-only; the ownerless operator-status family is deleted; templates are private; query mutations require the body; missing reads preserve filesystem absence. Next audit remaining projections, caches, schedulers, adapters, and non-receipt smokes for borrowed authority or path escape. - `swarm-overview` is an Epiphany-local, renderer-neutral diagnostic projection over provider-owned typed state. It owns no lifecycle, discovery, composition, or mutation authority. Epiphany publishes clean provider-owned Eve surfaces; Odin may discover them; downstream lowerers and compositors remain outside Epiphany's concern. - Idunn owns daemon survival and service lifecycle physiology. Codex/operator sessions may inspect, generate runbooks, and route explicit operator authority, but keeping daemons alive belongs to Idunn-owned service lifecycle receipts, scheduler policy, audits, and aftercare. Do not let Self, diagnostic projections, or ad hoc wrapper summaries become a second daemon-keeper. Global tool readbacks for Self `service-health`, `service-policy-directory`, and `swarm-online-runbook` state `lifecycleOwner=Idunn` and `hostedBody=Epiphany` without service mutation or private-state exposure. - Use `notes/epiphany-cultmesh-dreaming-roadmap.md` as the design authority for distributed Epiphany dreaming. Public dreams are separately authored typed documents distributed through CultMesh/CultNet; private state remains local and cannot be shared by flipping a visibility flag. Foreign dreams are external thought weather until a reviewed local adoption receipt digests them into memory, planning, doctrine, or governance. @@ -150,7 +150,7 @@ accepted_design: - Distributed Epiphany dreaming is a CultMesh typed-document problem, not prompt folklore. CultCache owns local typed documents, Epiphany owns export/import/adoption policy, CultNet owns wire/provenance/shard delivery, and CultMesh owns Verses, peer exchange, leases, shard logs, replicas, and watchable runtime surfaces. Start with local dream document types and a local store before public Verse wiring. - The local CultMesh daemon tool directory now has both discovery and invocation receipts at the operator edge. `epiphany-verse-query tools` lists globally available, receipt-gated daemon capabilities; `epiphany-verse-query invoke-tool --capability-id ` records `epiphany.cultmesh.daemon_tool_invocation_intent.v0` plus `epiphany.cultmesh.daemon_tool_invocation_receipt.v0` from the advertised capability, reports requesting/host display names, body domains, private Verse ids, and Eve surfaces from cluster topology, and refuses when the host daemon is not ready. Down-host refusals now surface Idunn-owned liveness sight and poke routes directly in the wrapper failure text: `epiphany-verse-query swarm-status`, `tools/epiphany_local_run.ps1 -Mode swarm-poke-down`, and the single-daemon `poke-daemon` command. `tools/epiphany_local_run.ps1 -Mode tool-invoke` wraps the same path with explicit requester/capability/intent/receipt parameters. Tool availability is global across local agents, but execution and authority remain with the hosting daemon and its typed receipt contract. Status tools now embed `daemonStatusReadback` with host cluster id, daemon status, body domain/kind, private Verse id, Eve surface, hosted tool capability ids, and private-state seal; live wrapper proof `local-20260619-015644-193-d31ca95c` routed Persona to Hands `status` and printed `daemonStatus=status=ready:cluster=epiphany.cluster.hands:daemon=epiphany-daemon-hands:surface=eve://epiphany/hands:tools=3:private=False`. Eve connection tools now embed `eveConnectionReadback` with target cluster/surface, public discussion eligibility, supported actions, connection command, wrapper connection command, feedback route, and private-state seal while leaving actual connection receipt creation to `connect-eve`; live wrapper proof `local-20260619-020458-304-b180a17c` routed Persona to Persona `eve-connect` and printed `eveConnection=target=epiphany.cluster.persona:surface=eve://epiphany/persona:publicDiscussion=True:actions=3:private=False`. Hands/Soul authority tools now embed `authorityToolReadback` so global invocation returns the authority gate, input contract, receipt contract, intent/receipt routes, host cluster, and private-state seal without pretending the tool bus owns action or verification; live wrapper proofs `local-20260619-021628-143-7bf7f2e0` and `local-20260619-021701-458-852cfa6f` routed Persona to Hands `repo-action` and Soul `verify` with `privateStateExposed=false`. The Self-hosted `service-health` tool embeds `serviceHealthReadback` in the invocation result instead of only pointing at receipt-directory: live wrapper proof `local-20260619-030519-499-6eb086de` returned status `attention`, Idunn service lifecycle/action rows, failed-check anatomy, `onlinePreflightStatus=ready-for-elevated-operator`, two child runbooks present, two hashes verified, zero missing artifacts, and no private-state exposure. Production invocation and source smoke now share `service_health_readback_from_idunn`, and the smoke rejects payloads that lose Idunn ownership, service lifecycle/action rows, failed-check anatomy, swarm-online preflight proof, or the private-state seal. - The local Verse swarm brake is now operator-writable from the same CLI surface and enforced at the main local wrapper plus direct coordinator/heartbeat runner edges. `epiphany-verse-query swarm-brake --brake-status engaged|released` writes the typed `epiphany.cultmesh.swarm_brake.v0` document with scope, reason, operator id, affected clusters, protected surfaces, expiry, and private-state seal. `tools/epiphany_local_run.ps1` queries that document before live `plan`, `run`, or `mvp` work and fails closed when engaged; `status` remains readable. `epiphany-mvp-coordinator --local-verse-store ` refuses before app-server startup when the brake is engaged, and `epiphany-heartbeat-store tick|pump|heat|queue-mention|routine --local-verse-store ` refuses heartbeat-driving work while leaving init/status/complete/repair-stale outside that live-run brake. - - The first Rust CultMesh integration slice is landed and repaired to compile from repo-contained vendored crates. `vendor/cultmesh-rs` is a small Rust node/database facade over vendored CultCache and CultNet with document-set registration and durable typed put/get/delete. `vendor/cultcache-rs` now reads and writes the `cultcache.store.v1` snapshot format used by `state/ledgers.msgpack`, so `epiphany-state status` is a working re-entry rite again. `epiphany-core` depends on `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`, exposes an `EpiphanyCultMeshStatusEntry`, records typed `EpiphanyCultMeshVersePolicyEntry` documents for the internal/local-area/global Verse tiers, and records typed `EpiphanyCultMeshGlobalRoomPolicyEntry` documents for threaded public global rooms such as dreams, architecture, research, Personas, GameCult, and governance. Native operator status is now a typed `EpiphanyCultMeshOperatorStatusEntry` in the internal Verse; it names Codex as bridge transport, Epiphany as authority owner, prompt-authority separation, and the quarantined Rider/Unity optional surfaces. Native operator snapshots are typed `EpiphanyCultMeshOperatorSnapshotEntry` documents distilled from operator-safe status artifacts; local status runs write operator run intent, operator snapshot, and run receipt into `.epiphany-run/cultmesh/local-verse.ccmp`, leaving JSON artifacts as display/evidence rather than the local-run read authority. + - The first Rust CultMesh integration slice is landed and repaired to compile from repo-contained vendored crates. `vendor/cultmesh-rs` is a small Rust node/database facade over vendored CultCache and CultNet with document-set registration and durable typed put/get/delete. `vendor/cultcache-rs` now reads and writes the `cultcache.store.v1` snapshot format used by `state/ledgers.msgpack`, so `epiphany-state status` is a working re-entry rite again. `epiphany-core` depends on `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`, exposes an `EpiphanyCultMeshStatusEntry`, records typed Verse policy and global-room documents, and records operator snapshots distilled from named operator-safe status artifacts. Local status runs write operator run intent, operator snapshot, and run receipt into `.epiphany-run/cultmesh/local-verse.ccmp`, leaving JSON artifacts as display/evidence rather than the local-run read authority. The former writerless operator-status schema family is deleted; it had no observer and no authority. - Mind's CultNet contract surface is native enough for the next Aquarium/CultMesh cut: `epiphany-core::mind_gateway` defines thought, state-effect proposal, gateway-review, commit-receipt, rejection-receipt, and Verse-adoption document contracts; runtime-spine advertises those mutation/read contracts; CultMesh persists matching `EpiphanyCultMeshMindContractEntry` policy documents so the private state guardian boundary is inspectable as typed state. - Substrate Gate contract surface is now named beside Mind's state gate: `epiphany-core::substrate_gate` defines repo access requests, access reviews, grant/refusal receipts, snapshot receipts, and mutation receipts; runtime-spine advertises those contracts; CultMesh persists matching `EpiphanyCultMeshSubstrateGateContractEntry` policy documents so repo substrate access has its own typed guardian instead of hiding behind worker launch scope. - Eyes' evidence contract surface is named beside Substrate Gate and Mind: `epiphany-core::eyes_gateway` defines evidence requests, evidence reviews, source lookup receipts, evidence packets, and evidence refusal receipts; runtime-spine advertises those contracts; CultMesh persists matching `EpiphanyCultMeshEyesContractEntry` policy documents so retrieved snippets and source reads are not confused with inspected evidence. @@ -536,10 +536,9 @@ current_status: CodexThread learns an explicit runtime-store override. This is scaffolding over the current compatibility shell, not a new policy owner. - Native CultMesh operator status is landed too: `epiphany-core` can write, - read, and smoke `epiphany.cultmesh.operator_status.v0`; runtime-spine - advertises it as the read-only operator status contract, and the active - schema catalog no longer advertises Rider/Unity bridge surfaces. + The former `epiphany.cultmesh.operator_status.v0` family is deleted because + no observer owned it. Runtime-spine and prompt context expose only the + source-derived operator snapshot and run-witness families. The next operator snapshot cut is landed: `epiphany-operator-snapshot` distills the operator-safe MVP status artifact into `epiphany.cultmesh.operator_snapshot.v0`, runtime-spine advertises that