From 1aa70f989067794fcb3130ecc9b4db666ed2e5a8 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 13 May 2026 01:11:22 +0100 Subject: [PATCH] Extract Epiphany context projection --- notes/fresh-workspace-handoff.md | 16 +- notes/json-contamination-ledger.md | 2 +- state/ledgers.msgpack | Bin 71889 -> 72210 bytes state/map.yaml | 4 +- .../app-server/src/codex_message_processor.rs | 252 +---------------- .../app-server/src/epiphany_context.rs | 258 ++++++++++++++++++ vendor/codex/codex-rs/app-server/src/lib.rs | 1 + 7 files changed, 274 insertions(+), 259 deletions(-) create mode 100644 vendor/codex/codex-rs/app-server/src/epiphany_context.rs diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 45dc4767..62d0485b 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -416,18 +416,20 @@ The fourth cut moved scene projection into `vendor/codex/codex-rs/app-server/src/epiphany_scene.rs`, taking the processor to about 20,059 lines. The fifth cut moved freshness/reorientation input mapping into `vendor/codex/codex-rs/app-server/src/epiphany_reorient.rs`, -taking the processor to about 19,708 lines. This is progress, not absolution: -handlers, context/planning/graph/jobs/roles/coordinator mappers, route -orchestration, accept policy plumbing, and tests still keep too much Epiphany -inside Codex. +taking the processor to about 19,708 lines. The sixth cut moved +context/planning/graph-query projection into +`vendor/codex/codex-rs/app-server/src/epiphany_context.rs`, taking the processor +to about 19,462 lines. This is progress, not absolution: handlers, +jobs/roles/coordinator mappers, route orchestration, accept policy plumbing, and +tests still keep too much Epiphany inside Codex. Also: MCP itself is allowed to be JSON. The target is not "replace MCP JSON"; the target is an Epiphany-owned boundary that speaks typed Epiphany intent/result/receipt documents internally and normal MCP JSON-RPC externally. -Continue with the actual whale-carcass cut: extract Epiphany route handlers, -result/projection mappers, coordinator glue, and remaining policy-shaped code -out of `codex_message_processor.rs` into Epiphany-owned app-server modules, +Continue with the actual whale-carcass cut: extract Epiphany jobs/roles/ +coordinator projection mappers, route handlers, and remaining policy-shaped +code out of `codex_message_processor.rs` into Epiphany-owned app-server modules, moving logic further into `epiphany-core` whenever it owns real policy. Success is a visibly smaller `codex_message_processor.rs`, not merely nicer payload names. Do not resume Rider, Unity, Aquarium, Face, dogfood, planning, app, diff --git a/notes/json-contamination-ledger.md b/notes/json-contamination-ledger.md index 94fad164..d4862755 100644 --- a/notes/json-contamination-ledger.md +++ b/notes/json-contamination-ledger.md @@ -62,6 +62,6 @@ Rule: JSON is allowed at external schema/wire boundaries. Inside Epiphany, live 3. Done: replace role `statePatch` JSON with typed map/planning/graph patch documents. `EpiphanyRoleFindingInterpretation` now carries `EpiphanyRoleStatePatchDocument`; app-server maps it to the legacy protocol patch without JSON round-tripping. 4. Done: replace runtime job result JSON projections. Runtime-spine results now project through typed role/reorient interpreters instead of `runtime_job_result_to_role_json` and `runtime_job_result_to_reorient_json`. 5. Done: replace app-server launch protocol `input_json` / `output_schema_json` with typed launch documents and `output_contract_id`. -6. Continue the whale-carcass cut: the first cuts moved Epiphany launch doctrine and protocol-to-core launch document mapping into `epiphany_launch.rs`, role/reorient result projection into `epiphany_results.rs`, scene projection into `epiphany_scene.rs`, and freshness/reorientation mapping into `epiphany_reorient.rs`, reducing `codex_message_processor.rs` from about 21,263 to 19,708 lines. Next move route handlers, remaining view projection mappers, coordinator glue, and policy-shaped code out of the processor; success means the processor keeps shrinking and ownership gets clearer, not merely better typed. +6. Continue the whale-carcass cut: the first cuts moved Epiphany launch doctrine and protocol-to-core launch document mapping into `epiphany_launch.rs`, role/reorient result projection into `epiphany_results.rs`, scene projection into `epiphany_scene.rs`, freshness/reorientation mapping into `epiphany_reorient.rs`, and context/planning/graph-query projection into `epiphany_context.rs`, reducing `codex_message_processor.rs` from about 21,263 to 19,462 lines. Next move jobs/roles/coordinator projection mappers, route handlers, and policy-shaped code out of the processor; success means the processor keeps shrinking and ownership gets clearer, not merely better typed. 7. Seal MCP payloads behind an Epiphany boundary that speaks typed Epiphany documents internally and MCP JSON externally. 8. Audit heartbeat cognition values and either type them or explicitly expire them. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 5627e6e826f0cb139d149429a79b10d952129443..1ca8d35178c7cd110c6257028e2b7b6a3ea88d6a 100644 GIT binary patch delta 142 zcmcb(k!8{rmI=yCk~cQ0PGe-;*}R8w`yNKd|6-H%OL;jAjYA9!tPBmOFJNTUVZZq= zIJ2T8W4fRSqr6OVeqKpxMTvevPGVkOW?s5}dQoCQhHhbLYEk9%U1E$@Y!DUGZ6z2L n1We3~6ml~2Qj2vI40S9F45yzHVf356TY{0B8)}7>p;;6F(G)Hi delta 43 ycmbQVh2`Q#mI=yC64N)TPGe-;(Y%Lo`yNKd|6, - params: &ThreadEpiphanyContextParams, -) -> ( - ThreadEpiphanyContextStateStatus, - Option, - ThreadEpiphanyContext, - ThreadEpiphanyContextMissing, -) { - map_core_epiphany_context_view(derive_context( - state, - &CoreEpiphanyContextParams { - graph_node_ids: params.graph_node_ids.clone(), - graph_edge_ids: params.graph_edge_ids.clone(), - observation_ids: params.observation_ids.clone(), - evidence_ids: params.evidence_ids.clone(), - include_active_frontier: params.include_active_frontier, - include_linked_evidence: params.include_linked_evidence, - }, - )) -} - -fn map_core_epiphany_context_view( - view: EpiphanyContextView, -) -> ( - ThreadEpiphanyContextStateStatus, - Option, - ThreadEpiphanyContext, - ThreadEpiphanyContextMissing, -) { - ( - map_core_epiphany_context_state_status(view.state_status), - view.state_revision, - map_core_epiphany_context(view.context), - map_core_epiphany_context_missing(view.missing), - ) -} - -fn map_core_epiphany_context_state_status( - status: CoreEpiphanyContextStateStatus, -) -> ThreadEpiphanyContextStateStatus { - match status { - CoreEpiphanyContextStateStatus::Missing => ThreadEpiphanyContextStateStatus::Missing, - CoreEpiphanyContextStateStatus::Ready => ThreadEpiphanyContextStateStatus::Ready, - } -} - -fn map_core_epiphany_context(context: CoreEpiphanyContext) -> ThreadEpiphanyContext { - ThreadEpiphanyContext { - graph: map_core_epiphany_graph_context(context.graph), - frontier: context.frontier, - checkpoint: context.checkpoint, - investigation_checkpoint: context.investigation_checkpoint, - observations: context.observations, - evidence: context.evidence, - } -} - -fn map_core_epiphany_graph_context(graph: CoreEpiphanyGraphContext) -> ThreadEpiphanyGraphContext { - ThreadEpiphanyGraphContext { - architecture_nodes: graph.architecture_nodes, - architecture_edges: graph.architecture_edges, - dataflow_nodes: graph.dataflow_nodes, - dataflow_edges: graph.dataflow_edges, - links: graph.links, - } -} - -fn map_core_epiphany_context_missing( - missing: CoreEpiphanyContextMissing, -) -> ThreadEpiphanyContextMissing { - ThreadEpiphanyContextMissing { - graph_node_ids: missing.graph_node_ids, - graph_edge_ids: missing.graph_edge_ids, - observation_ids: missing.observation_ids, - evidence_ids: missing.evidence_ids, - } -} - -fn map_epiphany_planning( - state: Option<&EpiphanyThreadState>, -) -> ( - ThreadEpiphanyContextStateStatus, - Option, - EpiphanyPlanningState, - ThreadEpiphanyPlanningSummary, -) { - let view = derive_planning_view(state); - map_core_epiphany_planning_view(view) -} - -fn map_core_epiphany_planning_view( - view: EpiphanyPlanningView, -) -> ( - ThreadEpiphanyContextStateStatus, - Option, - EpiphanyPlanningState, - ThreadEpiphanyPlanningSummary, -) { - ( - match view.state_status { - CoreEpiphanyPlanningStateStatus::Missing => ThreadEpiphanyContextStateStatus::Missing, - CoreEpiphanyPlanningStateStatus::Ready => ThreadEpiphanyContextStateStatus::Ready, - }, - view.state_revision, - view.planning, - map_core_epiphany_planning_summary(view.summary), - ) -} - -fn map_core_epiphany_planning_summary( - summary: CoreEpiphanyPlanningSummary, -) -> ThreadEpiphanyPlanningSummary { - ThreadEpiphanyPlanningSummary { - capture_count: summary.capture_count, - pending_capture_count: summary.pending_capture_count, - github_issue_capture_count: summary.github_issue_capture_count, - backlog_item_count: summary.backlog_item_count, - ready_backlog_item_count: summary.ready_backlog_item_count, - roadmap_stream_count: summary.roadmap_stream_count, - objective_draft_count: summary.objective_draft_count, - draft_objective_count: summary.draft_objective_count, - active_objective: summary.active_objective, - note: summary.note, - } -} - -fn map_epiphany_graph_query( - state: Option<&EpiphanyThreadState>, - query: &ThreadEpiphanyGraphQuery, -) -> ( - ThreadEpiphanyContextStateStatus, - Option, - ThreadEpiphanyGraphContext, - Option, - Option, - ThreadEpiphanyGraphQueryMatched, - ThreadEpiphanyGraphQueryMissing, -) { - map_core_epiphany_graph_query_view(derive_graph_query( - state, - &map_core_epiphany_graph_query(query), - )) -} - -fn map_core_epiphany_graph_query(query: &ThreadEpiphanyGraphQuery) -> CoreEpiphanyGraphQuery { - CoreEpiphanyGraphQuery { - kind: map_core_epiphany_graph_query_kind(query.kind), - node_ids: query.node_ids.clone(), - edge_ids: query.edge_ids.clone(), - paths: query.paths.clone(), - symbols: query.symbols.clone(), - edge_kinds: query.edge_kinds.clone(), - direction: query.direction.map(map_core_epiphany_graph_query_direction), - depth: query.depth, - include_links: query.include_links, - } -} - -fn map_core_epiphany_graph_query_kind( - kind: ThreadEpiphanyGraphQueryKind, -) -> CoreEpiphanyGraphQueryKind { - match kind { - ThreadEpiphanyGraphQueryKind::Node => CoreEpiphanyGraphQueryKind::Node, - ThreadEpiphanyGraphQueryKind::Path => CoreEpiphanyGraphQueryKind::Path, - ThreadEpiphanyGraphQueryKind::FrontierNeighborhood => { - CoreEpiphanyGraphQueryKind::FrontierNeighborhood - } - ThreadEpiphanyGraphQueryKind::Neighbors => CoreEpiphanyGraphQueryKind::Neighbors, - } -} - -fn map_core_epiphany_graph_query_direction( - direction: ThreadEpiphanyGraphQueryDirection, -) -> CoreEpiphanyGraphQueryDirection { - match direction { - ThreadEpiphanyGraphQueryDirection::Incoming => CoreEpiphanyGraphQueryDirection::Incoming, - ThreadEpiphanyGraphQueryDirection::Outgoing => CoreEpiphanyGraphQueryDirection::Outgoing, - ThreadEpiphanyGraphQueryDirection::Both => CoreEpiphanyGraphQueryDirection::Both, - } -} - -fn map_core_epiphany_graph_query_view( - view: EpiphanyGraphQueryView, -) -> ( - ThreadEpiphanyContextStateStatus, - Option, - ThreadEpiphanyGraphContext, - Option, - Option, - ThreadEpiphanyGraphQueryMatched, - ThreadEpiphanyGraphQueryMissing, -) { - ( - map_core_epiphany_context_state_status(view.state_status), - view.state_revision, - map_core_epiphany_graph_context(view.graph), - view.frontier, - view.checkpoint, - map_core_epiphany_graph_query_matched(view.matched), - map_core_epiphany_graph_query_missing(view.missing), - ) -} - -fn map_core_epiphany_graph_query_matched( - matched: CoreEpiphanyGraphQueryMatched, -) -> ThreadEpiphanyGraphQueryMatched { - ThreadEpiphanyGraphQueryMatched { - node_ids: matched.node_ids, - edge_ids: matched.edge_ids, - paths: matched.paths, - symbols: matched.symbols, - edge_kinds: matched.edge_kinds, - } -} - -fn map_core_epiphany_graph_query_missing( - missing: CoreEpiphanyGraphQueryMissing, -) -> ThreadEpiphanyGraphQueryMissing { - ThreadEpiphanyGraphQueryMissing { - node_ids: missing.node_ids, - edge_ids: missing.edge_ids, - } -} - pub(crate) async fn maybe_run_epiphany_coordinator_automation_for_turn_boundary( thread_id: ThreadId, thread: Arc, diff --git a/vendor/codex/codex-rs/app-server/src/epiphany_context.rs b/vendor/codex/codex-rs/app-server/src/epiphany_context.rs new file mode 100644 index 00000000..1d7a6ffe --- /dev/null +++ b/vendor/codex/codex-rs/app-server/src/epiphany_context.rs @@ -0,0 +1,258 @@ +use codex_app_server_protocol::ThreadEpiphanyContext; +use codex_app_server_protocol::ThreadEpiphanyContextMissing; +use codex_app_server_protocol::ThreadEpiphanyContextParams; +use codex_app_server_protocol::ThreadEpiphanyContextStateStatus; +use codex_app_server_protocol::ThreadEpiphanyGraphContext; +use codex_app_server_protocol::ThreadEpiphanyGraphQuery; +use codex_app_server_protocol::ThreadEpiphanyGraphQueryDirection; +use codex_app_server_protocol::ThreadEpiphanyGraphQueryKind; +use codex_app_server_protocol::ThreadEpiphanyGraphQueryMatched; +use codex_app_server_protocol::ThreadEpiphanyGraphQueryMissing; +use codex_app_server_protocol::ThreadEpiphanyPlanningSummary; +use codex_protocol::protocol::EpiphanyGraphCheckpoint; +use codex_protocol::protocol::EpiphanyGraphFrontier; +use codex_protocol::protocol::EpiphanyPlanningState; +use codex_protocol::protocol::EpiphanyThreadState; +use epiphany_core::EpiphanyContext as CoreEpiphanyContext; +use epiphany_core::EpiphanyContextMissing as CoreEpiphanyContextMissing; +use epiphany_core::EpiphanyContextParams as CoreEpiphanyContextParams; +use epiphany_core::EpiphanyContextStateStatus as CoreEpiphanyContextStateStatus; +use epiphany_core::EpiphanyContextView; +use epiphany_core::EpiphanyGraphContext as CoreEpiphanyGraphContext; +use epiphany_core::EpiphanyGraphQuery as CoreEpiphanyGraphQuery; +use epiphany_core::EpiphanyGraphQueryDirection as CoreEpiphanyGraphQueryDirection; +use epiphany_core::EpiphanyGraphQueryKind as CoreEpiphanyGraphQueryKind; +use epiphany_core::EpiphanyGraphQueryMatched as CoreEpiphanyGraphQueryMatched; +use epiphany_core::EpiphanyGraphQueryMissing as CoreEpiphanyGraphQueryMissing; +use epiphany_core::EpiphanyGraphQueryView; +use epiphany_core::EpiphanyPlanningStateStatus as CoreEpiphanyPlanningStateStatus; +use epiphany_core::EpiphanyPlanningSummary as CoreEpiphanyPlanningSummary; +use epiphany_core::EpiphanyPlanningView; +use epiphany_core::derive_context; +use epiphany_core::derive_graph_query; +use epiphany_core::derive_planning_view; + +pub(super) fn map_epiphany_context( + state: Option<&EpiphanyThreadState>, + params: &ThreadEpiphanyContextParams, +) -> ( + ThreadEpiphanyContextStateStatus, + Option, + ThreadEpiphanyContext, + ThreadEpiphanyContextMissing, +) { + map_core_epiphany_context_view(derive_context( + state, + &CoreEpiphanyContextParams { + graph_node_ids: params.graph_node_ids.clone(), + graph_edge_ids: params.graph_edge_ids.clone(), + observation_ids: params.observation_ids.clone(), + evidence_ids: params.evidence_ids.clone(), + include_active_frontier: params.include_active_frontier, + include_linked_evidence: params.include_linked_evidence, + }, + )) +} + +fn map_core_epiphany_context_view( + view: EpiphanyContextView, +) -> ( + ThreadEpiphanyContextStateStatus, + Option, + ThreadEpiphanyContext, + ThreadEpiphanyContextMissing, +) { + ( + map_core_epiphany_context_state_status(view.state_status), + view.state_revision, + map_core_epiphany_context(view.context), + map_core_epiphany_context_missing(view.missing), + ) +} + +fn map_core_epiphany_context_state_status( + status: CoreEpiphanyContextStateStatus, +) -> ThreadEpiphanyContextStateStatus { + match status { + CoreEpiphanyContextStateStatus::Missing => ThreadEpiphanyContextStateStatus::Missing, + CoreEpiphanyContextStateStatus::Ready => ThreadEpiphanyContextStateStatus::Ready, + } +} + +fn map_core_epiphany_context(context: CoreEpiphanyContext) -> ThreadEpiphanyContext { + ThreadEpiphanyContext { + graph: map_core_epiphany_graph_context(context.graph), + frontier: context.frontier, + checkpoint: context.checkpoint, + investigation_checkpoint: context.investigation_checkpoint, + observations: context.observations, + evidence: context.evidence, + } +} + +fn map_core_epiphany_graph_context(graph: CoreEpiphanyGraphContext) -> ThreadEpiphanyGraphContext { + ThreadEpiphanyGraphContext { + architecture_nodes: graph.architecture_nodes, + architecture_edges: graph.architecture_edges, + dataflow_nodes: graph.dataflow_nodes, + dataflow_edges: graph.dataflow_edges, + links: graph.links, + } +} + +fn map_core_epiphany_context_missing( + missing: CoreEpiphanyContextMissing, +) -> ThreadEpiphanyContextMissing { + ThreadEpiphanyContextMissing { + graph_node_ids: missing.graph_node_ids, + graph_edge_ids: missing.graph_edge_ids, + observation_ids: missing.observation_ids, + evidence_ids: missing.evidence_ids, + } +} + +pub(super) fn map_epiphany_planning( + state: Option<&EpiphanyThreadState>, +) -> ( + ThreadEpiphanyContextStateStatus, + Option, + EpiphanyPlanningState, + ThreadEpiphanyPlanningSummary, +) { + let view = derive_planning_view(state); + map_core_epiphany_planning_view(view) +} + +fn map_core_epiphany_planning_view( + view: EpiphanyPlanningView, +) -> ( + ThreadEpiphanyContextStateStatus, + Option, + EpiphanyPlanningState, + ThreadEpiphanyPlanningSummary, +) { + ( + match view.state_status { + CoreEpiphanyPlanningStateStatus::Missing => ThreadEpiphanyContextStateStatus::Missing, + CoreEpiphanyPlanningStateStatus::Ready => ThreadEpiphanyContextStateStatus::Ready, + }, + view.state_revision, + view.planning, + map_core_epiphany_planning_summary(view.summary), + ) +} + +fn map_core_epiphany_planning_summary( + summary: CoreEpiphanyPlanningSummary, +) -> ThreadEpiphanyPlanningSummary { + ThreadEpiphanyPlanningSummary { + capture_count: summary.capture_count, + pending_capture_count: summary.pending_capture_count, + github_issue_capture_count: summary.github_issue_capture_count, + backlog_item_count: summary.backlog_item_count, + ready_backlog_item_count: summary.ready_backlog_item_count, + roadmap_stream_count: summary.roadmap_stream_count, + objective_draft_count: summary.objective_draft_count, + draft_objective_count: summary.draft_objective_count, + active_objective: summary.active_objective, + note: summary.note, + } +} + +pub(super) fn map_epiphany_graph_query( + state: Option<&EpiphanyThreadState>, + query: &ThreadEpiphanyGraphQuery, +) -> ( + ThreadEpiphanyContextStateStatus, + Option, + ThreadEpiphanyGraphContext, + Option, + Option, + ThreadEpiphanyGraphQueryMatched, + ThreadEpiphanyGraphQueryMissing, +) { + map_core_epiphany_graph_query_view(derive_graph_query( + state, + &map_core_epiphany_graph_query(query), + )) +} + +fn map_core_epiphany_graph_query(query: &ThreadEpiphanyGraphQuery) -> CoreEpiphanyGraphQuery { + CoreEpiphanyGraphQuery { + kind: map_core_epiphany_graph_query_kind(query.kind), + node_ids: query.node_ids.clone(), + edge_ids: query.edge_ids.clone(), + paths: query.paths.clone(), + symbols: query.symbols.clone(), + edge_kinds: query.edge_kinds.clone(), + direction: query.direction.map(map_core_epiphany_graph_query_direction), + depth: query.depth, + include_links: query.include_links, + } +} + +fn map_core_epiphany_graph_query_kind( + kind: ThreadEpiphanyGraphQueryKind, +) -> CoreEpiphanyGraphQueryKind { + match kind { + ThreadEpiphanyGraphQueryKind::Node => CoreEpiphanyGraphQueryKind::Node, + ThreadEpiphanyGraphQueryKind::Path => CoreEpiphanyGraphQueryKind::Path, + ThreadEpiphanyGraphQueryKind::FrontierNeighborhood => { + CoreEpiphanyGraphQueryKind::FrontierNeighborhood + } + ThreadEpiphanyGraphQueryKind::Neighbors => CoreEpiphanyGraphQueryKind::Neighbors, + } +} + +fn map_core_epiphany_graph_query_direction( + direction: ThreadEpiphanyGraphQueryDirection, +) -> CoreEpiphanyGraphQueryDirection { + match direction { + ThreadEpiphanyGraphQueryDirection::Incoming => CoreEpiphanyGraphQueryDirection::Incoming, + ThreadEpiphanyGraphQueryDirection::Outgoing => CoreEpiphanyGraphQueryDirection::Outgoing, + ThreadEpiphanyGraphQueryDirection::Both => CoreEpiphanyGraphQueryDirection::Both, + } +} + +fn map_core_epiphany_graph_query_view( + view: EpiphanyGraphQueryView, +) -> ( + ThreadEpiphanyContextStateStatus, + Option, + ThreadEpiphanyGraphContext, + Option, + Option, + ThreadEpiphanyGraphQueryMatched, + ThreadEpiphanyGraphQueryMissing, +) { + ( + map_core_epiphany_context_state_status(view.state_status), + view.state_revision, + map_core_epiphany_graph_context(view.graph), + view.frontier, + view.checkpoint, + map_core_epiphany_graph_query_matched(view.matched), + map_core_epiphany_graph_query_missing(view.missing), + ) +} + +fn map_core_epiphany_graph_query_matched( + matched: CoreEpiphanyGraphQueryMatched, +) -> ThreadEpiphanyGraphQueryMatched { + ThreadEpiphanyGraphQueryMatched { + node_ids: matched.node_ids, + edge_ids: matched.edge_ids, + paths: matched.paths, + symbols: matched.symbols, + edge_kinds: matched.edge_kinds, + } +} + +fn map_core_epiphany_graph_query_missing( + missing: CoreEpiphanyGraphQueryMissing, +) -> ThreadEpiphanyGraphQueryMissing { + ThreadEpiphanyGraphQueryMissing { + node_ids: missing.node_ids, + edge_ids: missing.edge_ids, + } +} diff --git a/vendor/codex/codex-rs/app-server/src/lib.rs b/vendor/codex/codex-rs/app-server/src/lib.rs index b255ccc1..271e3b7d 100644 --- a/vendor/codex/codex-rs/app-server/src/lib.rs +++ b/vendor/codex/codex-rs/app-server/src/lib.rs @@ -75,6 +75,7 @@ mod config_manager; mod config_manager_service; mod device_key_api; mod dynamic_tools; +mod epiphany_context; mod epiphany_invalidation; mod epiphany_launch; mod epiphany_reorient;