diff --git a/epiphany-codex-bridge/src/launch.rs b/epiphany-codex-bridge/src/launch.rs index bd88dd34..206a0d5f 100644 --- a/epiphany-codex-bridge/src/launch.rs +++ b/epiphany-codex-bridge/src/launch.rs @@ -453,7 +453,6 @@ pub fn build_epiphany_role_launch_request( investigation_checkpoint: state.investigation_checkpoint.clone(), scratch: state.scratch.clone(), invariants: state.invariants.clone(), - graphs: None, recent_evidence: state.recent_evidence.iter().take(8).cloned().collect(), recent_observations: state.observations.iter().take(8).cloned().collect(), graph_frontier: state.graph_frontier.clone(), @@ -668,7 +667,6 @@ pub fn build_epiphany_reorient_launch_request( .collect(), scratch: state.scratch.clone(), memory_context: build_reorient_memory_context(state, checkpoint, decision, memory_graph_snapshot), - graphs: None, recent_evidence: state.recent_evidence.iter().take(8).cloned().collect(), recent_observations: state.observations.iter().take(8).cloned().collect(), active_frontier_node_ids: decision.active_frontier_node_ids.clone(), @@ -736,7 +734,6 @@ fn map_core_role_worker_launch_document( investigation_checkpoint: document.investigation_checkpoint, scratch: document.scratch, invariants: document.invariants, - graphs: document.graphs, recent_evidence: document.recent_evidence, recent_observations: document.recent_observations, graph_frontier: document.graph_frontier, @@ -771,7 +768,6 @@ fn map_core_reorient_worker_launch_document( checkpoint_changed_paths: document.checkpoint_changed_paths, scratch: document.scratch, memory_context: document.memory_context, - graphs: document.graphs, recent_evidence: document.recent_evidence, recent_observations: document.recent_observations, active_frontier_node_ids: document.active_frontier_node_ids, @@ -854,10 +850,6 @@ mod tests { let EpiphanyWorkerLaunchDocument::Role(document) = launch.launch_document else { panic!("expected role launch document"); }; - assert!( - document.graphs.is_none(), - "native role launch should use typed memoryContext instead of full graph cargo" - ); let context = document .memory_context .expect("role launch should carry typed memory context"); @@ -925,10 +917,6 @@ mod tests { let EpiphanyWorkerLaunchDocument::Reorient(document) = launch.launch_document else { panic!("expected reorient launch document"); }; - assert!( - document.graphs.is_none(), - "native reorient launch should use typed memoryContext instead of full graph cargo" - ); let context = document .memory_context .expect("reorient launch should carry typed memory context"); diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index b91dac74..03616133 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -2025,7 +2025,6 @@ mod tests { investigation_checkpoint: None, scratch: None, invariants: Vec::new(), - graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, @@ -2091,7 +2090,6 @@ mod tests { investigation_checkpoint: None, scratch: None, invariants: Vec::new(), - graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, diff --git a/epiphany-core/src/surfaces/worker_launch.rs b/epiphany-core/src/surfaces/worker_launch.rs index 99d8b400..5953dd81 100644 --- a/epiphany-core/src/surfaces/worker_launch.rs +++ b/epiphany-core/src/surfaces/worker_launch.rs @@ -3,7 +3,6 @@ use epiphany_state_model::EpiphanyCodeRef; use epiphany_state_model::EpiphanyEvidenceRecord; use epiphany_state_model::EpiphanyGraphCheckpoint; use epiphany_state_model::EpiphanyGraphFrontier; -use epiphany_state_model::EpiphanyGraphs; use epiphany_state_model::EpiphanyInvariant; use epiphany_state_model::EpiphanyInvestigationCheckpoint; use epiphany_state_model::EpiphanyMemoryContextPacket; @@ -62,8 +61,6 @@ pub struct EpiphanyRoleWorkerLaunchDocument { pub scratch: Option, #[serde(default)] pub invariants: Vec, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub graphs: Option, #[serde(default)] pub recent_evidence: Vec, #[serde(default)] @@ -112,8 +109,6 @@ pub struct EpiphanyReorientWorkerLaunchDocument { pub scratch: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub memory_context: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub graphs: Option, #[serde(default)] pub recent_evidence: Vec, #[serde(default)] diff --git a/epiphany-openai-runtime/src/lib.rs b/epiphany-openai-runtime/src/lib.rs index 1d437853..2cc03192 100644 --- a/epiphany-openai-runtime/src/lib.rs +++ b/epiphany-openai-runtime/src/lib.rs @@ -918,7 +918,6 @@ mod tests { investigation_checkpoint: None, scratch: None, invariants: Vec::new(), - graphs: None, recent_evidence: Vec::new(), recent_observations: Vec::new(), graph_frontier: None, diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index e1fa1473..2e11d80e 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. Public `ThreadEpiphanyUpdatePatch` no longer carries `graphs`; generic update/promote bridge mutation mapping cannot apply it, and native state-update validation plus promotion policy reject it as backstop. `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. +- `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 internally to derive that packet when the store is missing. Worker launch documents no longer carry 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. Public `ThreadEpiphanyUpdatePatch` no longer carries `graphs`; generic update/promote bridge mutation mapping cannot apply it, and native state-update validation plus promotion policy reject it as backstop. `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 ff5f5b26..51dd59d9 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 5c8f8815..f651f328 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`; public `ThreadEpiphanyUpdatePatch` no longer carries `graphs`, generic update/promote bridge mutations cannot map it, and native state-update validation plus promotion policy reject it as backstop; 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. + - 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 an internal bootstrap fallback for deriving that packet when the memory graph store is absent, not launch-document cargo. The old `thread/epiphany/propose` read route now exposes graph growth as typed `memoryPatchCandidates` instead of replacement `graphs`; public `ThreadEpiphanyUpdatePatch` no longer carries `graphs`, generic update/promote bridge mutations cannot map it, and native state-update validation plus promotion policy reject it as backstop; 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`; public `ThreadEpiphanyUpdatePatch` no longer carries `graphs`; generic update/promote bridge mutation mapping, 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 deciding whether worker launch document `graphs` bootstrap fallback can be deleted now that persisted memoryContext is preferred. + 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`, never carry full graph cargo in launch documents, and use accepted thread graphs only as an internal memoryContext bootstrap fallback when the store is missing; 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`; public `ThreadEpiphanyUpdatePatch` no longer carries `graphs`; generic update/promote bridge mutation mapping, 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 shrinking the legacy `EpiphanyThreadState.graphs` read/propose compatibility path itself. diff --git a/vendor/codex/codex-rs/app-server-protocol/schema/json/ClientRequest.json b/vendor/codex/codex-rs/app-server-protocol/schema/json/ClientRequest.json index 923ff826..c331283f 100644 --- a/vendor/codex/codex-rs/app-server-protocol/schema/json/ClientRequest.json +++ b/vendor/codex/codex-rs/app-server-protocol/schema/json/ClientRequest.json @@ -6822,16 +6822,6 @@ } ] }, - "graphs": { - "anyOf": [ - { - "$ref": "#/definitions/EpiphanyGraphs" - }, - { - "type": "null" - } - ] - }, "invariants": { "type": "array", "items": { @@ -6994,16 +6984,6 @@ "graphStatus": { "type": "string" }, - "graphs": { - "anyOf": [ - { - "$ref": "#/definitions/EpiphanyGraphs" - }, - { - "type": "null" - } - ] - }, "linkedGraphNodeIds": { "type": "array", "items": { diff --git a/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json b/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json index 1c40ba8e..eb60e935 100644 --- a/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json +++ b/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json @@ -8515,16 +8515,6 @@ } ] }, - "graphs": { - "anyOf": [ - { - "$ref": "#/definitions/v2/EpiphanyGraphs" - }, - { - "type": "null" - } - ] - }, "invariants": { "type": "array", "items": { @@ -8687,16 +8677,6 @@ "graphStatus": { "type": "string" }, - "graphs": { - "anyOf": [ - { - "$ref": "#/definitions/v2/EpiphanyGraphs" - }, - { - "type": "null" - } - ] - }, "linkedGraphNodeIds": { "type": "array", "items": { diff --git a/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json b/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json index 14c5edef..19637928 100644 --- a/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json +++ b/vendor/codex/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json @@ -3941,16 +3941,6 @@ } ] }, - "graphs": { - "anyOf": [ - { - "$ref": "#/definitions/EpiphanyGraphs" - }, - { - "type": "null" - } - ] - }, "invariants": { "type": "array", "items": { @@ -4113,16 +4103,6 @@ "graphStatus": { "type": "string" }, - "graphs": { - "anyOf": [ - { - "$ref": "#/definitions/EpiphanyGraphs" - }, - { - "type": "null" - } - ] - }, "linkedGraphNodeIds": { "type": "array", "items": { diff --git a/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyReorientWorkerLaunchDocument.ts b/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyReorientWorkerLaunchDocument.ts index 0051c767..5b612832 100644 --- a/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyReorientWorkerLaunchDocument.ts +++ b/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyReorientWorkerLaunchDocument.ts @@ -3,8 +3,7 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. import type { EpiphanyCodeRef } from "../EpiphanyCodeRef"; import type { EpiphanyEvidenceRecord } from "../EpiphanyEvidenceRecord"; -import type { EpiphanyGraphs } from "../EpiphanyGraphs"; import type { EpiphanyObservation } from "../EpiphanyObservation"; import type { EpiphanyScratchPad } from "../EpiphanyScratchPad"; -export type ThreadEpiphanyReorientWorkerLaunchDocument = { threadId: string, mode: string, checkpointId: string, checkpointKind: string, checkpointDisposition: string, checkpointFocus?: string | null, checkpointSummary?: string | null, checkpointNextAction: string, checkpointOpenQuestions?: Array, checkpointEvidenceIds?: Array, checkpointCodeRefs?: Array, decisionReasons?: Array, decisionNote: string, pressureLevel: string, retrievalStatus: string, graphStatus: string, watcherStatus: string, checkpointDirtyPaths?: Array, checkpointChangedPaths?: Array, scratch?: EpiphanyScratchPad | null, graphs?: EpiphanyGraphs | null, recentEvidence?: Array, recentObservations?: Array, activeFrontierNodeIds?: Array, linkedSubgoalIds?: Array, linkedGraphNodeIds?: Array, }; +export type ThreadEpiphanyReorientWorkerLaunchDocument = { threadId: string, mode: string, checkpointId: string, checkpointKind: string, checkpointDisposition: string, checkpointFocus?: string | null, checkpointSummary?: string | null, checkpointNextAction: string, checkpointOpenQuestions?: Array, checkpointEvidenceIds?: Array, checkpointCodeRefs?: Array, decisionReasons?: Array, decisionNote: string, pressureLevel: string, retrievalStatus: string, graphStatus: string, watcherStatus: string, checkpointDirtyPaths?: Array, checkpointChangedPaths?: Array, scratch?: EpiphanyScratchPad | null, recentEvidence?: Array, recentObservations?: Array, activeFrontierNodeIds?: Array, linkedSubgoalIds?: Array, linkedGraphNodeIds?: Array, }; diff --git a/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyRoleWorkerLaunchDocument.ts b/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyRoleWorkerLaunchDocument.ts index 69f0fae0..d06595a2 100644 --- a/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyRoleWorkerLaunchDocument.ts +++ b/vendor/codex/codex-rs/app-server-protocol/schema/typescript/v2/ThreadEpiphanyRoleWorkerLaunchDocument.ts @@ -5,7 +5,6 @@ import type { EpiphanyChurnState } from "../EpiphanyChurnState"; import type { EpiphanyEvidenceRecord } from "../EpiphanyEvidenceRecord"; import type { EpiphanyGraphCheckpoint } from "../EpiphanyGraphCheckpoint"; import type { EpiphanyGraphFrontier } from "../EpiphanyGraphFrontier"; -import type { EpiphanyGraphs } from "../EpiphanyGraphs"; import type { EpiphanyInvariant } from "../EpiphanyInvariant"; import type { EpiphanyInvestigationCheckpoint } from "../EpiphanyInvestigationCheckpoint"; import type { EpiphanyObservation } from "../EpiphanyObservation"; @@ -13,4 +12,4 @@ import type { EpiphanyPlanningState } from "../EpiphanyPlanningState"; import type { EpiphanyScratchPad } from "../EpiphanyScratchPad"; import type { EpiphanySubgoal } from "../EpiphanySubgoal"; -export type ThreadEpiphanyRoleWorkerLaunchDocument = { threadId: string, roleId: string, stateRevision: bigint, objective?: string | null, activeSubgoalId?: string | null, activeSubgoals?: Array, activeGraphNodeIds?: Array, investigationCheckpoint?: EpiphanyInvestigationCheckpoint | null, scratch?: EpiphanyScratchPad | null, invariants?: Array, graphs?: EpiphanyGraphs | null, recentEvidence?: Array, recentObservations?: Array, graphFrontier?: EpiphanyGraphFrontier | null, graphCheckpoint?: EpiphanyGraphCheckpoint | null, planning?: EpiphanyPlanningState | null, churn?: EpiphanyChurnState | null, }; +export type ThreadEpiphanyRoleWorkerLaunchDocument = { threadId: string, roleId: string, stateRevision: bigint, objective?: string | null, activeSubgoalId?: string | null, activeSubgoals?: Array, activeGraphNodeIds?: Array, investigationCheckpoint?: EpiphanyInvestigationCheckpoint | null, scratch?: EpiphanyScratchPad | null, invariants?: Array, recentEvidence?: Array, recentObservations?: Array, graphFrontier?: EpiphanyGraphFrontier | null, graphCheckpoint?: EpiphanyGraphCheckpoint | null, planning?: EpiphanyPlanningState | null, churn?: EpiphanyChurnState | null, }; diff --git a/vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs b/vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs index 02095283..81b7ac1d 100644 --- a/vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs +++ b/vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs @@ -66,7 +66,6 @@ use codex_protocol::protocol::EpiphanyGraphEdge as CoreEpiphanyGraphEdge; use codex_protocol::protocol::EpiphanyGraphFrontier as CoreEpiphanyGraphFrontier; use codex_protocol::protocol::EpiphanyGraphLink as CoreEpiphanyGraphLink; use codex_protocol::protocol::EpiphanyGraphNode as CoreEpiphanyGraphNode; -use codex_protocol::protocol::EpiphanyGraphs as CoreEpiphanyGraphs; use codex_protocol::protocol::EpiphanyInvariant as CoreEpiphanyInvariant; use codex_protocol::protocol::EpiphanyInvestigationCheckpoint as CoreEpiphanyInvestigationCheckpoint; use codex_protocol::protocol::EpiphanyInvestigationDisposition as CoreEpiphanyInvestigationDisposition; @@ -5241,9 +5240,6 @@ pub struct ThreadEpiphanyRoleWorkerLaunchDocument { pub scratch: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub invariants: Vec, - #[serde(default, skip_serializing_if = "Option::is_none")] - #[ts(optional = nullable)] - pub graphs: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub recent_evidence: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] @@ -5301,9 +5297,6 @@ pub struct ThreadEpiphanyReorientWorkerLaunchDocument { #[serde(default, skip_serializing_if = "Option::is_none")] #[ts(optional = nullable, type = "CoreEpiphanyMemoryContextPacket | null")] pub memory_context: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - #[ts(optional = nullable)] - pub graphs: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub recent_evidence: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")]