From f7d3698a56b51f4f4675bb697a80cfa3b2ef11b7 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 18 May 2026 06:06:14 +0100 Subject: [PATCH] Isolate legacy graph projection --- .../src/legacy_graph_compat.rs | 14 ++++++++++ epiphany-codex-bridge/src/lib.rs | 1 + epiphany-codex-bridge/src/view.rs | 24 ++++++------------ notes/fresh-workspace-handoff.md | 2 +- state/ledgers.msgpack | Bin 142384 -> 142645 bytes state/map.yaml | 4 +-- 6 files changed, 26 insertions(+), 19 deletions(-) create mode 100644 epiphany-codex-bridge/src/legacy_graph_compat.rs diff --git a/epiphany-codex-bridge/src/legacy_graph_compat.rs b/epiphany-codex-bridge/src/legacy_graph_compat.rs new file mode 100644 index 00000000..2e518d0f --- /dev/null +++ b/epiphany-codex-bridge/src/legacy_graph_compat.rs @@ -0,0 +1,14 @@ +use codex_protocol::protocol::EpiphanyThreadState; +use epiphany_core::EpiphanyMemoryGraphSnapshot; +use epiphany_core::epiphany_graphs_from_memory_graph; + +pub fn thread_state_with_legacy_graph_projection( + state: Option<&EpiphanyThreadState>, + memory_graph_snapshot: Option<&EpiphanyMemoryGraphSnapshot>, +) -> Option { + state.zip(memory_graph_snapshot).map(|(state, snapshot)| { + let mut state = state.clone(); + state.graphs = epiphany_graphs_from_memory_graph(snapshot); + state + }) +} diff --git a/epiphany-codex-bridge/src/lib.rs b/epiphany-codex-bridge/src/lib.rs index c8ecd4ae..6dc024d0 100644 --- a/epiphany-codex-bridge/src/lib.rs +++ b/epiphany-codex-bridge/src/lib.rs @@ -4,6 +4,7 @@ pub mod coordinator; pub mod invalidation; pub mod jobs; pub mod launch; +pub mod legacy_graph_compat; pub mod mutation; pub mod mutation_service; pub mod pressure; diff --git a/epiphany-codex-bridge/src/view.rs b/epiphany-codex-bridge/src/view.rs index 6a146adb..9337f4f4 100644 --- a/epiphany-codex-bridge/src/view.rs +++ b/epiphany-codex-bridge/src/view.rs @@ -10,7 +10,6 @@ use epiphany_core::EpiphanyMemoryGraphSnapshot; use epiphany_core::EpiphanySceneInput; use epiphany_core::derive_scene; use epiphany_core::distill_observation; -use epiphany_core::epiphany_graphs_from_memory_graph; use epiphany_core::propose_map_update; use crate::context::map_epiphany_context; @@ -24,6 +23,7 @@ use crate::coordinator::map_epiphany_roles; use crate::coordinator::render_epiphany_roles_note; use crate::jobs::map_epiphany_jobs; use crate::launch::EPIPHANY_REORIENT_LAUNCH_BINDING_ID; +use crate::legacy_graph_compat::thread_state_with_legacy_graph_projection; use crate::pressure::map_epiphany_pressure; use crate::reorient::EpiphanyFreshnessWatcherSnapshot; use crate::reorient::map_epiphany_freshness; @@ -84,7 +84,7 @@ pub fn map_epiphany_freshness_response( input: EpiphanyFreshnessResponseInput<'_>, ) -> ThreadEpiphanyFreshnessResponse { let memory_backed_state = - memory_backed_thread_state(input.state, input.memory_graph_snapshot); + thread_state_with_legacy_graph_projection(input.state, input.memory_graph_snapshot); let state = memory_backed_state.as_ref().or(input.state); let (state_revision, retrieval, graph, watcher) = map_epiphany_freshness( state, @@ -112,7 +112,8 @@ pub fn map_epiphany_context_response( memory_graph_snapshot: Option<&EpiphanyMemoryGraphSnapshot>, params: &ThreadEpiphanyContextParams, ) -> ThreadEpiphanyContextResponse { - let memory_backed_state = memory_backed_thread_state(state, memory_graph_snapshot); + let memory_backed_state = + thread_state_with_legacy_graph_projection(state, memory_graph_snapshot); let state = memory_backed_state.as_ref().or(state); let (state_status, state_revision, context, missing) = map_epiphany_context(state, params); ThreadEpiphanyContextResponse { @@ -136,7 +137,8 @@ pub fn map_epiphany_graph_query_response( memory_graph_snapshot: Option<&EpiphanyMemoryGraphSnapshot>, query: &ThreadEpiphanyGraphQuery, ) -> ThreadEpiphanyGraphQueryResponse { - let memory_backed_state = memory_backed_thread_state(state, memory_graph_snapshot); + let memory_backed_state = + thread_state_with_legacy_graph_projection(state, memory_graph_snapshot); let state = memory_backed_state.as_ref().or(state); let (state_status, state_revision, graph, frontier, checkpoint, matched, missing) = map_epiphany_graph_query(state, query); @@ -157,17 +159,6 @@ pub fn map_epiphany_graph_query_response( } } -fn memory_backed_thread_state( - state: Option<&EpiphanyThreadState>, - memory_graph_snapshot: Option<&EpiphanyMemoryGraphSnapshot>, -) -> Option { - state.zip(memory_graph_snapshot).map(|(state, snapshot)| { - let mut state = state.clone(); - state.graphs = epiphany_graphs_from_memory_graph(snapshot); - state - }) -} - pub struct EpiphanyViewResponseInput<'a> { pub thread_id: String, pub lenses: Vec, @@ -194,7 +185,8 @@ pub async fn map_epiphany_view_response( token_usage_info, runtime_store_path, } = input; - let memory_backed_state = memory_backed_thread_state(state, memory_graph_snapshot); + let memory_backed_state = + thread_state_with_legacy_graph_projection(state, memory_graph_snapshot); let state = memory_backed_state.as_ref().or(state); let needs_jobs = epiphany_view_needs_jobs(&lenses); diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index d4be4e60..e1e512a5 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -39,7 +39,7 @@ remembers doctrine; the branch remembers the blade. - `epiphany-openai-runtime` worker result ingress now parses assistant output directly into typed role/reorient ingress structs selected from the durable launch document, stores nested `statePatch` and `selfPatch` as typed MessagePack in `EpiphanyRuntimeRoleWorkerResult`, and no longer passes worker result data through generic `serde_json::Value`. JSON survives there only as the OpenAI text-output edge before typed deserialization. - Agent self-memory review/application now has typed `AgentSelfPatch` core APIs. JSON-value selfPatch functions are compatibility wrappers for CLI/artifact ingress; native callers should parse once at the edge and then call `review_agent_self_patch_document` / `apply_agent_self_patch_document`. Role-result self-persistence no longer exports a JSON-value reviewer; the live API is `review_role_self_patch_document`. - `epiphany-openai-codex-spine` no longer uses Codex's Responses client, model-provider layer, `codex-api`, `codex-model-provider`, `codex-model-provider-info`, or `codex-protocol` for outbound model requests. It reaches `codex-login` only through `epiphany-openai-auth-spine` so credential loading/refresh stays Codex-compatible while request/status/event/runtime surfaces stay typed Epiphany documents. -- `notes/epiphany-memory-graph-unified-plan.md` is the current memory architecture direction drawn from `Fractal Domains And The Cache That Bites` plus the VoidBot memory scar tissue. The repo semantic architecture/dataflow graph and agent memory are one `EpiphanyMemoryGraph` substrate with repo, role, short-term, incubation, agency, candidate-intervention, and evidence profiles. The first native skeleton is landed: `epiphany-state-model` owns shared graph document types, `epiphany-core::memory_graph` owns stable ids, validation, freshness, context cuts, and CultCache persistence, and `epiphany-memory-graph` can status/validate/context/semantic-context/smoke/index the store. `epiphany-core::semantic_cache` now owns the shared Qdrant/Ollama transport used by workspace retrieval and memory graph indexing, so Qdrant remains a rebuildable contribution cache for typed graph documents, not truth. Runtime role results expose typed `memoryPatchCandidates`; Modeling `roleAccept` applies them to `state/memory-graph.msgpack`; native role/reorientation launches now prefer that persisted memory graph for bounded typed `memoryContext` cuts and only fall back to legacy accepted thread graphs for bootstrap. Reorientation launch no longer carries full `graphs` cargo. The old `thread/epiphany/propose` read route no longer returns replacement `graphs`; it exposes graph growth as typed `memoryPatchCandidates` and withholds frontier updates that depend on unapplied memory growth. Generic `thread/epiphany/update` and `thread/epiphany/promote` reject `patch.graphs` at the bridge; native state-update validation and promotion policy reject it too. `thread/epiphany/view`, `thread/epiphany/freshness`, `thread/epiphany/context`, and `thread/epiphany/graphQuery` now prefer the persisted memory graph for loaded threads through one read-route store adapter and project back into legacy graph-shaped response lenses only at the bridge edge. `notes/repo-fractal-dataflow-cache-plan.md` and `notes/agent-memory-fractal-cache-plan.md` are profile plans, not rival organs. +- `notes/epiphany-memory-graph-unified-plan.md` is the current memory architecture direction drawn from `Fractal Domains And The Cache That Bites` plus the VoidBot memory scar tissue. The repo semantic architecture/dataflow graph and agent memory are one `EpiphanyMemoryGraph` substrate with repo, role, short-term, incubation, agency, candidate-intervention, and evidence profiles. The first native skeleton is landed: `epiphany-state-model` owns shared graph document types, `epiphany-core::memory_graph` owns stable ids, validation, freshness, context cuts, and CultCache persistence, and `epiphany-memory-graph` can status/validate/context/semantic-context/smoke/index the store. `epiphany-core::semantic_cache` now owns the shared Qdrant/Ollama transport used by workspace retrieval and memory graph indexing, so Qdrant remains a rebuildable contribution cache for typed graph documents, not truth. Runtime role results expose typed `memoryPatchCandidates`; Modeling `roleAccept` applies them to `state/memory-graph.msgpack`; native role/reorientation launches now prefer that persisted memory graph for bounded typed `memoryContext` cuts and only fall back to legacy accepted thread graphs for bootstrap. Reorientation launch no longer carries full `graphs` cargo. The old `thread/epiphany/propose` read route no longer returns replacement `graphs`; it exposes graph growth as typed `memoryPatchCandidates` and withholds frontier updates that depend on unapplied memory growth. Generic `thread/epiphany/update` and `thread/epiphany/promote` reject `patch.graphs` at the bridge; native state-update validation and promotion policy reject it too. `thread/epiphany/view`, `thread/epiphany/freshness`, `thread/epiphany/context`, and `thread/epiphany/graphQuery` now prefer the persisted memory graph for loaded threads through one read-route store adapter and project back into legacy graph-shaped response lenses only through `epiphany-codex-bridge::legacy_graph_compat`. `notes/repo-fractal-dataflow-cache-plan.md` and `notes/agent-memory-fractal-cache-plan.md` are profile plans, not rival organs. - Durable Epiphany state types now live in root crate `epiphany-state-model`. `codex-protocol` re-exports them only so old rollout/API callers keep compiling; do not add new durable `Epiphany*` state structs under `vendor/codex`. `epiphany-core` imports the native model directly and no longer depends on `codex-protocol`. Pressure derives from native `EpiphanyTokenUsageSnapshot`; Codex token telemetry is mapped at the bridge. Codex rollout/event reconstruction now lives in `codex-core::epiphany_rollout`, where the Codex `RolloutItem` / `EventMsg` types belong. Exact retrieval path matching is native to `epiphany-core`, so `epiphany-core` has no direct vendored Codex crate dependency. - State-update contract proof and job launch/interrupt DTO ownership now live in native `epiphany-core`. The old giant `codex_thread.rs` Epiphany state-update test fixture was cut, and `epiphany-codex-bridge` no longer imports Epiphany job launch request types from `codex_core`; vendored `CodexThread` may call the native mutation/launch law for compatibility, but it must not regain ownership of state-update semantics, heartbeat launch-plan policy, or Epiphany DTOs. - MCP remains JSON because MCP is a JSON protocol. The latest processor cut only moved MCP refresh/OAuth/status/resource/tool-call route handling into `codex_message_processor/mcp_routes.rs`, reducing the root processor to about 8,977 lines; it did not claim MCP payloads are CultNet or make MCP an Epiphany-owned runtime contract. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 7c9c78129e541a2e9dc98142c430afb51ec67d5c..9c06460f6a9b23daf63cc8d01e1077b0b4cc1a2b 100644 GIT binary patch delta 261 zcmdmRgJbJ0jtR<4I=?rnPGe+jXx_uvzK4-<`yNK7I4#kZMJ2^MjSP&;bPY^(4J|?p zOsxz|ryuZP)UmmF$R{;DF}YG9y(qCDL$^31u^=@?p(wSuAV04-RiU6LKPxr4Br`ux zA+uN^FTWf}<>w@p0M%sXO&5$}6sxzg$^n}Y4>ln_IX|}`vBX-TEHkxSuc%ld8E8&v zZfdbYW(iPBaY<@oib8&xLVkH(W?s5NNk*zdZfb6RQKc@#0VVmmB^gCPMG!tnKghhy cq|BVml1hc*jLclUhAl{b;RJie%EUMd0M6`PL;wH) delta 53 zcmdmbi(|tLjtR<4+TS*+PGe-OZ{EY$zK4-<`yNK7I4!Y;Ek*`LX1WHZx`q}Z2Bua9 JMpmX~Q2-K45dHuF diff --git a/state/map.yaml b/state/map.yaml index b8c73e2a..5bdcd856 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -75,7 +75,7 @@ active_subgoals: - The May 2026 teardown/rebuild migration in `notes/epiphany-ideal-architecture-rebuild-plan.md` is closed unless a concrete regression reopens it. Preserve the new foundation: Epiphany view/coordinator policy lives in `epiphany-core`, runtime-spine owns job/result lifecycle identity through `runtime_links`, duplicate acceptance is receipt-keyed, public findings stay typed/sealed, view expansion requires a core contract, and app-server remains routing/adaptation rather than a second policy throne. - Treat Phase 5 update/distill/propose/promote/read/notification as complete enough unless a concrete regression appears. - Preserve read-only boundaries for retrieve, distill, propose, freshness, context, graphQuery, roleResult, reorientResult, and the canonical view lenses for scene, jobs, roles, planning, pressure, reorient, crrc, and coordinator. - - Use `notes/epiphany-memory-graph-unified-plan.md` as the source-grounded memory architecture direction. The repo fractal dataflow graph and agent memory are one `EpiphanyMemoryGraph` substrate with repo, role, short-term, incubation, agency, candidate-intervention, and evidence profiles. Qdrant stores rebuildable semantic embeddings for typed graph documents; it is never canonical memory. The first live skeleton now exists in `epiphany-state-model` plus `epiphany-core::memory_graph`: typed graph documents, stable ids, validation, freshness propagation, context cuts, a CultCache store seam, deterministic embedding documents, manifest persistence, Qdrant rebuild through shared semantic-cache transport, and semantic context fallback that resolves cache hits back through the typed graph. Modeling graph growth now travels as typed `memoryPatchCandidates`, is applied during `roleAccept` into `state/memory-graph.msgpack`, and future role/reorientation launches prefer that persisted graph for bounded typed `memoryContext` cuts; accepted thread graphs are only bootstrap fallback. The old `thread/epiphany/propose` read route now exposes graph growth as typed `memoryPatchCandidates` instead of replacement `graphs`; generic update/promote bridge mutations, native state-update validation, and promotion policy reject `patch.graphs`; view/freshness/context/graphQuery read the persisted memory graph for loaded threads through one read-route store adapter. Do not add repo scanners, sleep runners, prompt integration, or ranking shortcuts before routing them through this shared substrate. + - Use `notes/epiphany-memory-graph-unified-plan.md` as the source-grounded memory architecture direction. The repo fractal dataflow graph and agent memory are one `EpiphanyMemoryGraph` substrate with repo, role, short-term, incubation, agency, candidate-intervention, and evidence profiles. Qdrant stores rebuildable semantic embeddings for typed graph documents; it is never canonical memory. The first live skeleton now exists in `epiphany-state-model` plus `epiphany-core::memory_graph`: typed graph documents, stable ids, validation, freshness propagation, context cuts, a CultCache store seam, deterministic embedding documents, manifest persistence, Qdrant rebuild through shared semantic-cache transport, and semantic context fallback that resolves cache hits back through the typed graph. Modeling graph growth now travels as typed `memoryPatchCandidates`, is applied during `roleAccept` into `state/memory-graph.msgpack`, and future role/reorientation launches prefer that persisted graph for bounded typed `memoryContext` cuts; accepted thread graphs are only bootstrap fallback. The old `thread/epiphany/propose` read route now exposes graph growth as typed `memoryPatchCandidates` instead of replacement `graphs`; generic update/promote bridge mutations, native state-update validation, and promotion policy reject `patch.graphs`; view/freshness/context/graphQuery read the persisted memory graph for loaded threads through one read-route store adapter, and legacy graph-shaped response projection is isolated in `epiphany-codex-bridge::legacy_graph_compat`. Do not add repo scanners, sleep runners, prompt integration, or ranking shortcuts before routing them through this shared substrate. - Keep the landed Phase 6 coordinator, limited safe-boundary CRRC automation, and pre-compaction checkpoint intervention ready for the next bridge-equipped dogfood run. - Preserve the Ghostlight-derived heartbeat initiative seam: every lane, including coordinator/Self and Face, has a role dossier and competes for heartbeat slots through readiness/reaction timing; idle winners ruminate instead of inventing project work, and sleep windows distill the accumulated thought pressure into reviewed self-memory or doctrine. - Treat Ghostlight as reference lineage, not a sibling runtime to preserve. The useful organ is Epiphany-native character-loop protocol: any role can project its typed dossier plus visible stimulus into a local turn packet, with Face as the first public-surface actor. @@ -297,4 +297,4 @@ current_status: freshness propagation, summary-versus-child context cuts, and a validated CultCache store entry; the native `epiphany-memory-graph` binary can status/validate/query/smoke the store without Qdrant. - next_action: Continue the memory graph build unless a more urgent Codex starvation regression appears. Repo, agent, and heartbeat profile producers now map accepted architecture/dataflow graph truth, reviewed role dossier memory/goals/values, and heartbeat cognition pressure into `EpiphanyMemoryGraph` documents; compose merges profile snapshots into one validated graph; `epiphany-memory-graph compose` writes from typed graph stores; `epiphany-memory-graph refresh` can invoke live agent-memory and heartbeat-cognition producers from their typed stores; `epiphany-core` has a native typed `EpiphanyThreadState` CultCache store seam; the bridge mirrors loaded Codex-thread Epiphany state into `state/thread-state.msgpack`; CultNet advertises logical `EpiphanyThreadState` plus `EpiphanyMemoryGraph` snapshot contracts; memory graph nodes/edges/summaries project into deterministic typed embedding documents; `epiphany-memory-graph manifest` writes the embedding manifest back to the typed graph store; `epiphany-core::semantic_cache` owns shared Qdrant/Ollama transport; `epiphany-memory-graph index` fully rebuilds Qdrant from typed graph documents while keeping the manifest in the graph store; `epiphany-memory-graph semantic-context` asks Qdrant for graph IDs only, preserves hit order, then resolves context from typed graph state with a no-cache fallback; native role/reorientation worker launches now prefer persisted `state/memory-graph.msgpack` for typed `memoryContext` and no longer carry full graph cargo on native paths; typed runtime role results can persist `memoryPatchCandidates`; `epiphany-core` can review/apply append-only candidate graph growth with lifecycle receipts; `epiphany-memory-graph review-candidate` / `apply-candidate` expose that law for typed candidate files; roleResult findings expose typed `memoryPatchCandidates` for pre-acceptance operator review; bridge Modeling `roleAccept` applies runtime-spine memory patch candidates into `state/memory-graph.msgpack` through the same graph law; roleAccept responses expose typed `memoryPatchReviews`; Modeling `statePatch.graphs` is rejected by policy/prompt/schema; `thread/epiphany/propose` now exposes graph growth as typed `memoryPatchCandidates`; generic update/promote bridge mutations, native state-update validation, and promotion policy reject `patch.graphs`; and `thread/epiphany/view`, freshness, context, and graphQuery now prefer the persisted memory graph for loaded threads through one read-route store adapter, projecting to legacy graph-shaped response lenses only at the edge. The next clean slice is moving remaining legacy graph fields behind an explicit compatibility module or deleting dead graph-replacement law that no live mutation path can use. + next_action: Continue the memory graph build unless a more urgent Codex starvation regression appears. Repo, agent, and heartbeat profile producers now map accepted architecture/dataflow graph truth, reviewed role dossier memory/goals/values, and heartbeat cognition pressure into `EpiphanyMemoryGraph` documents; compose merges profile snapshots into one validated graph; `epiphany-memory-graph compose` writes from typed graph stores; `epiphany-memory-graph refresh` can invoke live agent-memory and heartbeat-cognition producers from their typed stores; `epiphany-core` has a native typed `EpiphanyThreadState` CultCache store seam; the bridge mirrors loaded Codex-thread Epiphany state into `state/thread-state.msgpack`; CultNet advertises logical `EpiphanyThreadState` plus `EpiphanyMemoryGraph` snapshot contracts; memory graph nodes/edges/summaries project into deterministic typed embedding documents; `epiphany-memory-graph manifest` writes the embedding manifest back to the typed graph store; `epiphany-core::semantic_cache` owns shared Qdrant/Ollama transport; `epiphany-memory-graph index` fully rebuilds Qdrant from typed graph documents while keeping the manifest in the graph store; `epiphany-memory-graph semantic-context` asks Qdrant for graph IDs only, preserves hit order, then resolves context from typed graph state with a no-cache fallback; native role/reorientation worker launches now prefer persisted `state/memory-graph.msgpack` for typed `memoryContext` and no longer carry full graph cargo on native paths; typed runtime role results can persist `memoryPatchCandidates`; `epiphany-core` can review/apply append-only candidate graph growth with lifecycle receipts; `epiphany-memory-graph review-candidate` / `apply-candidate` expose that law for typed candidate files; roleResult findings expose typed `memoryPatchCandidates` for pre-acceptance operator review; bridge Modeling `roleAccept` applies runtime-spine memory patch candidates into `state/memory-graph.msgpack` through the same graph law; roleAccept responses expose typed `memoryPatchReviews`; Modeling `statePatch.graphs` is rejected by policy/prompt/schema; `thread/epiphany/propose` now exposes graph growth as typed `memoryPatchCandidates`; generic update/promote bridge mutations, native state-update validation, and promotion policy reject `patch.graphs`; and `thread/epiphany/view`, freshness, context, and graphQuery now prefer the persisted memory graph for loaded threads through one read-route store adapter, projecting to legacy graph-shaped response lenses only through `epiphany-codex-bridge::legacy_graph_compat`. The next clean slice is deleting remaining graph-replacement schema/DTO residue where compatibility no longer requires accepting it.