28 KiB
Fresh Workspace Handoff
What This Repo Is
EpiphanyAgent is a prototype workspace for upgrading AI coding harnesses so they stop confusing local motion with global understanding.
The working idea is simple enough:
- keep canonical understanding in typed state
- keep scratch bounded and disposable
- keep evidence durable
- make the harness consult that state instead of pretending the transcript is a brain
The project target is now the vendored Codex core harness itself, not a sidecar wrapper first and not some random GitHub "OpenCodex" contraption held together with hope and string.
Current Repo State
Important consequence:
vendor/codexis now tracked directly in the parent repo as ordinary files- it is not a submodule anymore
epiphany-core/is now a sibling repo-owned crate that holds the bulk of the Epiphany prompt, rollout replay, and retrieval/indexing logic instead of leaving that whole organ smeared through vendored Codex
Recent anchor commits:
2042687e3035c5a86d7f6aa66306d87abcc10f2d- vendored Codex and landed the Phase 1 Epiphany core state slicec823815- persisted the Phase 2 implementation plan and refreshed the project handoff/stateefd1420- landed and pushed the Phase 2 prompt-integration slice640e063- documented the pre-compaction Epiphany workflow and synced the repo memory before compaction360dfea- landed and pushed the Phase 4 hybrid retrieval slice80c29e0- extracted Epiphany core organs intoepiphany-core, landed explicit Qdrant indexing, and added licensing guardrails
Do not trust this note for the exact current HEAD; use git log --oneline -1 if you need the live commit.
Canonical project state still lives in:
state/map.yamlstate/scratch.mdstate/evidence.jsonl
Licensing State
- the repo now has a top-level
LICENSEfile that acts as an operative repository license notice rather than a policy draft vendor/codex/**remains governed by its upstream Apache-2.0 and related third-party notices- Project-Authored Material outside
vendor/codex/**is publicly licensed under PolyForm Noncommercial 1.0.0, with separate commercial licensing intended by written agreement - external contributions require
CONTRIBUTOR_LICENSE_AGREEMENT.mdor a separate written agreement accepted by the Project Steward; contributors keep ownership but grant broad sublicensing/relicensing rights so future commercial licensing is not blocked by old contribution archaeology - do not describe the repository as a whole as OSI Open Source unless and until the project-authored material is also published under an OSI-approved license
Current implementation plan note:
notes/epiphany-fork-implementation-plan.md
Current architectural/spec notes:
notes/codex-repository-algorithmic-map.mdnotes/epiphany-current-algorithmic-map.mdnotes/epiphany-core-harness-surfaces.md
Current Landed Baseline
Phase 4 repo-local hybrid retrieval is now landed on main. The first retrieval anchor is 360dfea; the current pushed baseline is 80c29e0, which also includes explicit Qdrant indexing, the epiphany-core extraction, and licensing guardrails. This is no longer a vague scaffold, a maybe, or a working-tree-only event.
Current verified pushed baseline after that first retrieval anchor:
- explicit
thread/epiphany/index - manifest-backed Qdrant semantic persistence under
codex_home - local Ollama embeddings by default
- stale/fresh retrieval summaries
- read-only
thread/epiphany/retrievewith BM25 fallback still intact - repo-owned
epiphany-coreextraction for the heavy prompt/replay/retrieval organ, leaving vendored Codex with thin adapters plus the typed host seam
Current verified working-tree follow-up:
- experimental loaded-thread-only
thread/epiphany/update - experimental loaded-thread-only
thread/epiphany/distill - experimental loaded-thread-only
thread/epiphany/promote - typed patch shape for observations, evidence, objective, subgoals, invariants, graphs, graph frontier/checkpoint, scratch, churn, and mode
- deterministic observation/evidence proposal generation in
epiphany-core - verifier-backed promotion policy evaluation in
epiphany-core - core
CodexThread.epiphany_update_state(...)applies the patch to liveSessionState, bumps revision, persistsRolloutItem::EpiphanyState, and flushes rollout - replay helpers in both
codex-coreandepiphany-coreaccept an out-of-band Epiphany snapshot before the first real user turn so seed/update snapshots survive resume - retrieval remains read-only and indexing remains the only persistent semantic write path
Live smoke for that follow-up:
- rebuilt
codex-app-server.exe - initialized app-server stdio with
experimentalApi: true - started ephemeral loaded thread
019dbffc-c19a-75e0-bf35-c780bee59a68rooted atE:\Projects\EpiphanyAgent\epiphany-core - called
thread/epiphany/updatewithexpectedRevision: 0 - response revision was
1 thread/readreturnedepiphanyState.revision == 1, objectiveSmoke-test explicit Epiphany update persistence, observationobs-update-smoke, and evidenceev-update-smoke- smoke result lives at
.epiphany-smoke/update-smoke-result.json - wire-shape footgun: app-server envelope fields are camelCase, but nested reused Epiphany core DTOs currently serialize with their core snake_case field names
Live smoke for the distillation follow-up:
- rebuilt
codex-app-server.exe - initialized app-server stdio with
experimentalApi: true - started ephemeral loaded thread
019dc028-99ce-7b03-8f89-65b072cc2ccarooted atE:\Projects\EpiphanyAgent\epiphany-core - called
thread/epiphany/distillwithsourceKind: smoke,status: ok, subjectthread/epiphany/distill, text, and a code ref tosrc/distillation.rs - distill returned
expectedRevision: 0plus observationobs-c9bfcac23d66and evidenceev-c9bfcac23d66in a patch - passing that patch to
thread/epiphany/updateadvanced state to revision1 thread/readreturned the generated observation/evidence ids inepiphanyState- smoke result lives at
.epiphany-smoke/distill-smoke-result.json
Live smoke for the promotion follow-up:
- rebuilt
codex-app-server.exe - initialized app-server stdio with
experimentalApi: true - started ephemeral loaded thread
019dc087-6d3d-7323-9a2f-2487a591ef7arooted atE:\Projects\EpiphanyAgent\epiphany-core - distilled a promotion smoke patch
thread/epiphany/promoterejected failed verifier evidence withaccepted: false, a rejection reason, and noepiphanyStatethread/readafter rejection had no Epiphany state, proving rejection did not mutate statethread/epiphany/promoteaccepted verifier evidence with statusok, appended verifier evidence, and applied through the durable update paththread/readreturned revision1, observationobs-77248505f492, patch evidenceev-77248505f492, and verifier evidenceev-promote-smoke-verifier- smoke result lives at
.epiphany-smoke/promote-smoke-result.json
Live smoke after the pushed baseline:
- built
codex-app-server.exewithCARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex - used an isolated
CODEX_HOMEat.epiphany-smoke/codex-home - started an ephemeral loaded app-server thread rooted at
E:\Projects\EpiphanyAgent\epiphany-core - preflighted the bounded smoke corpus as 5 tracked files / 106,748 bytes
thread/epiphany/indexagainst real local Qdrant/Ollama returned ready state with 5 indexed files and 198 chunks- Qdrant collection
epiphany_workspace_fa24bab116f8d229was created thread/epiphany/retrievereturned persistent semantic chunks fromsrc/prompt.rs, proving the fresh Qdrant path works after explicit indexing- env/default backend config is good enough for the current slice; do not build a first-class config surface yet unless a real operator pain appears
- unrelated app-server startup noise showed up during the smoke: project trust warning, plugin sync 403, and unauthenticated OpenAI websocket warning
Current verified implementation spans:
epiphany-core/Cargo.tomlepiphany-core/src/prompt.rsepiphany-core/src/rollout.rsepiphany-core/src/retrieval.rsepiphany-core/src/lib.rsvendor/codex/codex-rs/protocol/src/protocol.rsvendor/codex/codex-rs/core/src/epiphany_retrieval.rsvendor/codex/codex-rs/core/src/epiphany_rollout.rsvendor/codex/codex-rs/core/src/context/epiphany_state_instructions.rsvendor/codex/codex-rs/core/src/codex_thread.rsvendor/codex/codex-rs/core/src/lib.rsvendor/codex/codex-rs/core/Cargo.tomlvendor/codex/codex-rs/core/src/session/rollout_reconstruction.rsvendor/codex/codex-rs/core/src/session/rollout_reconstruction_tests.rsvendor/codex/codex-rs/core/src/session/tests.rsvendor/codex/codex-rs/app-server-protocol/src/protocol/common.rsvendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rsvendor/codex/codex-rs/app-server-protocol/src/export.rsvendor/codex/codex-rs/app-server/src/codex_message_processor.rsvendor/codex/codex-rs/app-server/README.md- regenerated stable fixtures under
vendor/codex/codex-rs/app-server-protocol/schema/
What is wired right now:
EpiphanyThreadStatealready has retrieval metadata fields and types in protocol- repo-owned
epiphany-corenow owns:- the prompt-state renderer used by Phase 2 prompt injection
- the rollout replay helper used by Phase 3 stored-thread hydration and rollback/compaction-aware reads
- the heavy retrieval/indexing engine used by the current Phase 4 work
- the deterministic observation distiller used by
thread/epiphany/distill - the promotion policy evaluator used by
thread/epiphany/promote
- vendored
codex-corenow keeps thin adapters at:core/src/epiphany_retrieval.rscore/src/epiphany_rollout.rscore/src/epiphany_distillation.rscore/src/epiphany_promotion.rscore/src/context/epiphany_state_instructions.rs
- the retrieval machine is still hybrid:
- exact/path-ish lookup via
codex_file_search - semantic lookup via BM25 chunk search over a local gitignore-respecting corpus
- exact/path-ish lookup via
CodexThreadnow exposes:epiphany_retrieval_state()epiphany_retrieve(...)epiphany_index(...)epiphany_update_state(...)
- app-server protocol now declares experimental
thread/epiphany/retrieve - app-server protocol now also declares experimental
thread/epiphany/index - app-server protocol now also declares experimental
thread/epiphany/distill - app-server protocol now also declares experimental
thread/epiphany/promote - app-server protocol now also declares experimental
thread/epiphany/update - app-server message handling now routes those methods through the core host seam
thread/epiphany/distillis the first read-only proposal surface; it returns anexpectedRevisionplus a patch and requires explicit promotion throughthread/epiphany/updatethread/epiphany/promoteis the first explicit promotion gate; it rejects failed verifier evidence without mutation and applies accepted candidates through the update paththread/epiphany/promotenow has a first richer map/churn safety layer: state replacement patches must carry explicit observations and patch evidence, and subgoal/invariant/graph/frontier/checkpoint/churn structure is validated before the durable update path is calledthread/epiphany/updateis the first explicit durable Epiphany state write surface; it rejects empty patches, supports optional revision matching, appends observations/evidence, replaces bounded typed fields, increments state revision, and persists immediately- live hydrated
thread.epiphanyStatereads now backfill a lightweight retrieval summary when the thread already has Epiphany state but no persisted retrieval summary yet - basic protocol/core/app-server unit tests were added for the new types and mapping layer
- the current pushed baseline additionally wires:
- Qdrant-backed semantic indexing behind an explicit write path instead of hidden retrieval mutation
- manifest-backed freshness checking under
codex_home - local Ollama embeddings by default, with support for adjacent VoidBot-style env names as fallbacks
- persistent semantic retrieval preference when the index is fresh, and BM25 fallback when it is stale, missing, or unavailable
- modified Codex alone is no longer the whole Epiphany organ; the heavier implementation now lives in the sibling crate and vendored Codex mostly hosts typed seams and adapters
Important recovery facts:
- existing exact/path lookup substrate already exists through
codex_file_search - app-server fuzzy search currently uses it in
vendor/codex/codex-rs/app-server/src/fuzzy_file_search.rs codex-corealready depends onbm25vendor/codex/codex-rs/core/src/tools/handlers/tool_search.rsalready shows how BM25 is used in-tree- tracked corpus preflight for
vendor/codex/codex-rsatvendor/codexHEADd45ab10is3642files /31.09 MB - raw working-tree size under
codex-rsis polluted by build artifacts and should not be used as the retrieval corpus estimate
Recovered bounded design decision:
- the first Phase 4 slice should be a query-time hybrid retriever
- reuse
codex_file_searchfor exact/path-ish lookup - use workspace-local BM25 chunk search as the initial semantic backend
- keep the first slice loaded-thread-only and read-only
- defer embeddings, vector stores, persistent indexing, and watcher-driven invalidation for later slices
Updated follow-up direction:
- the verified BM25 slice is still the right first landing zone
- the first persistent semantic store after that should target Qdrant rather than another blob-thrashing JSON/Postgres embedding store
- Qdrant should be the preferred persistent semantic backend later, not a hard requirement for basic Epiphany use
- exact/path lookup stays first-class
- BM25 should stay around as bootstrap/fallback/control for users who do not want Qdrant or when Qdrant is unavailable instead of turning the machine into vector-only confidence soup
What got verified:
cargo fmt --manifest-path E:\Projects\EpiphanyAgent\epiphany-core\Cargo.tomlpassedcargo test --manifest-path E:\Projects\EpiphanyAgent\epiphany-core\Cargo.tomlpassedcargo fmt --allpassedcargo test -p codex-core -p codex-app-server-protocol -p codex-app-server --lib --no-runpassed withCARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex- targeted Phase 4 tests passed:
cargo test -p codex-core --lib epiphanycargo test -p codex-app-server-protocol --lib thread_epiphany_cargo test -p codex-app-server --lib map_epiphany_
- full
cargo test -p codex-app-server-protocolpassed after regenerating stable schema fixtures
Notable verification fixes:
codex_message_processor.rsneeded the live-thread retrieval helper call to stop pretending&CodexThreadneeded.as_ref()core/src/session/tests.rsneededretrieval: Nonein the prompt fixture Epiphany state- the exact-hit retrieval test fixture needed a genuinely matchable file name (
session_checkpoint.rs) EpiphanyThreadStateneeded an explicit exemption in the protocol export test because sparse durable thread state intentionally uses optional fields
Important schema caveat:
cargo run -p codex-app-server-protocol --bin write_schema_fixtures -- --experimentalrewrites the same checked-in schema tree as stable generation- leaving the repo in that state makes stable protocol tests fail
- the safe checked-in state for this slice is the stable fixture generation output
- after inspection, do not bolt durable Epiphany-state writes onto
thread/epiphany/retrievejust because the retrieval summary exists:- current Epiphany snapshots are persisted on real user-turn boundaries
- out-of-band durable retrieval writes would need new rollout semantics and are a larger machine than this slice deserves
What Already Landed
Phase 1 is done.
The Phase 1 internal/dev-usable Epiphany core state slice was implemented inside vendored Codex:
RolloutItem::EpiphanyState(EpiphanyStateItem)existsSessionStatestoresepiphany_state- one Epiphany snapshot is persisted per real user turn
- rollout reconstruction restores the latest surviving snapshot across resume, rollback, and compaction
- rollout/state/app-server readers tolerate the new variant
- core persistence/replay tests were added
Main touched files:
vendor/codex/codex-rs/protocol/src/protocol.rsvendor/codex/codex-rs/core/src/state/session.rsvendor/codex/codex-rs/core/src/session/mod.rsvendor/codex/codex-rs/core/src/session/rollout_reconstruction.rsvendor/codex/codex-rs/core/src/session/tests.rsvendor/codex/codex-rs/core/src/session/rollout_reconstruction_tests.rs- plus rollout/state/app-server compatibility readers
Phase 2 is done too.
The Phase 2 prompt-integration slice was originally implemented inside vendored Codex and now renders through the repo-owned prompt crate with a thin wrapper in codex-core:
EpiphanyStateInstructionsrenders a bounded developer fragment fromEpiphanyThreadState- the fragment is wrapped in
<epiphany_state> ... </epiphany_state> Session::build_initial_contextinjects it immediately after collaboration-mode instructions whenSessionState.epiphany_stateexists- resumed sessions now pull the restored Epiphany state back into the prompt path instead of leaving it inert in rollout
- prompt-facing inclusion, omission, resume, bounded-rendering, and snapshot tests were added
Main touched files for Phase 2:
epiphany-core/src/prompt.rsvendor/codex/codex-rs/core/src/context/mod.rsvendor/codex/codex-rs/core/src/context/epiphany_state_instructions.rsvendor/codex/codex-rs/core/src/session/mod.rsvendor/codex/codex-rs/core/src/session/tests.rsvendor/codex/codex-rs/core/src/session/snapshots/codex_core__session__build_initial_context_epiphany_state.snapvendor/codex/codex-rs/protocol/src/protocol.rs
Phase 3 is landed too, in a conservative read-surface form.
What landed:
- app-server protocol
Threadpayloads now expose optional typedepiphany_state - hydrated thread responses prefer live
CodexThreadstate when a thread is loaded - stored thread reads fall back to rollout reconstruction through a shared core helper that respects rollback and compaction semantics
- the minimal typed client surface is now real without making prompt text the GUI data source
- dedicated Epiphany-specific update RPCs and live state notifications are still deferred
Main touched files for Phase 3:
epiphany-core/src/rollout.rsvendor/codex/codex-rs/core/src/epiphany_rollout.rsvendor/codex/codex-rs/core/src/lib.rsvendor/codex/codex-rs/core/src/codex_thread.rsvendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rsvendor/codex/codex-rs/app-server-protocol/src/protocol/common.rsvendor/codex/codex-rs/app-server/src/codex_message_processor.rsvendor/codex/codex-rs/app-server/README.md- compatibility fixture/test updates in
analytics,exec, andtui
There is now also a dedicated Epiphany algorithmic map:
notes/epiphany-current-algorithmic-map.md
Use it when you need the answer to "what machine is current Epiphany, as a fork, actually running right now?" without rereading the whole Codex machine map plus the whole future-facing spec.
What Must Be Remembered Before Compaction
If a future session wakes up from compaction and starts bluffing, this is the part to staple to its forehead.
- Phase 1, Phase 2, and the minimal Phase 3 read surface are all landed and verified.
- The current pushed Phase 4/core-extraction anchor is
80c29e0:Extract Epiphany core and add licensing guardrails
- The earlier Phase 4 slice 1 anchor is still
360dfea:Land Epiphany Phase 4 hybrid retrieval slice
vendor/codexis ordinary tracked repo content, not a submodule.- Phase 2 means Codex now reads Epiphany state during turn construction:
SessionState.epiphany_stateis the internal activation signalSession::build_initial_contextinjects a bounded<epiphany_state>developer fragment- resumed sessions reuse the restored Epiphany snapshot in the prompt path
- Phase 3 means clients can now read typed Epiphany state directly from hydrated
Threadpayloads:thread/start,thread/resume,thread/fork,thread/read,thread/unarchive, and detached review-thread startup can carrythread.epiphanyStatewhen present- loaded threads use live state
- stored thread reads reconstruct from rollout with the same rollback/compaction semantics as core
- there are still no dedicated Epiphany update RPCs or live
thread/epiphany/*notifications
- The next phase is not GUI work.
- The current landed phase is Phase 4 repo-local retrieval/indexing:
- Epiphany now has a real typed repo retrieval subsystem instead of repeated file-by-file shell archaeology
- persistent semantic indexing now exists behind explicit
thread/epiphany/index - the next bounded follow-up is live smoke and operational polish, not proving the retriever exists again
- The current pushed baseline also extracted most Epiphany-owned implementation into
epiphany-core:- prompt rendering, rollout replay, and retrieval/indexing logic are now repo-owned
- vendored Codex keeps the typed protocol/thread/app-server seam plus thin adapters
- Phase 4 slice 1 is now landed on
mainand was verified before landing:- protocol/core/app-server wiring exists and passed targeted verification
- stable app-server protocol schema fixtures were regenerated
write_schema_fixtures --experimentalis a trap if it is left as the checked-in tree
- The recovered bounded implementation choice for the first slice is:
- exact/path lookup via existing
codex_file_search - semantic lookup via local BM25 chunk search
- query-time, read-only, loaded-thread-first behavior
- no embeddings or persistent vector store yet
- exact/path lookup via existing
- The recovered boundary choice for the current follow-up is:
- keep the protocol/thread/app-server seam inside vendored Codex
- move heavy Epiphany-owned implementation into the sibling crate when that can be done without giving up first-class typed integration
- Important Windows verification footgun still stands:
- use
CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codexforcodex-corework on this machine
- use
- App-server stack-pressure footgun from the richer promotion slice:
- without a larger test-thread stack, unrelated app-server tests can overflow after the expanded request/promotion machinery
vendor/codex/codex-rs/.cargo/config.tomlnow setsRUST_MIN_STACK=67108864- do not remove that and then act shocked when Windows eats the test harness again
- Snapshot hygiene note:
- the new Epiphany prompt snapshot normalizes temp skill-root paths in the test harness so it stays stable across runs
Opinionated Workflow Rule
Epiphany should be an opinionated software development agent, not a generic chat model wearing a hard hat.
That means this persistence workflow is not optional ceremony. It should be part of the harness:
- before compaction, phase boundaries, or handoff:
- sync the canonical map
- append evidence
- refresh the handoff note
- make the next action explicit
- if context pressure is climbing toward compaction:
- stop pretending there is plenty of room left
- narrow the current move to a bounded landing zone
- persist the checkpoint before the hard limit actually trips
- compaction should happen from a known checkpoint, not at some random point in the middle of an implementation trance
- resumed work should start from the persisted checkpoint and next action, not from vibes and transcript archaeology
If the harness cannot do that by default later, it is not opinionated enough yet.
Verification That Already Happened
Rust and VS Build Tools were installed specifically so this would stop being interpretive dance.
Verified:
cargo fmt --all- full lib test suites passed for:
codex-protocolcodex-app-server-protocolcodex-rolloutcodex-state
- targeted new
codex-coreEpiphany persistence/replay tests passed - targeted
codex-coreepiphanytests passed after Phase 2 - broader
codex-corebuild_initial_context_*coverage passed after Phase 2 cargo fmt --allpassed again after Phase 3cargo test -p codex-core -p codex-app-server-protocol -p codex-app-server -p codex-analytics -p codex-exec -p codex-tui --lib --no-runpassed after the newThread.epiphanyStatefield fallout was patched- targeted Phase 3 tests passed:
cargo test -p codex-core --lib latest_epiphany_state_from_rollout_itemscargo test -p codex-app-server --lib load_epiphany_state_from_rollout_path_reads_latest_snapshotcargo test -p codex-app-server-protocol --lib serialize_client_response
cargo fmt --allpassed for the Phase 4 retrieval slicecargo test -p codex-core -p codex-app-server-protocol -p codex-app-server --lib --no-runpassed for the Phase 4 retrieval slice whenCARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex- targeted Phase 4 tests passed:
cargo test -p codex-core --lib retrieve_workspace_cargo test -p codex-app-server-protocol --lib thread_epiphany_retrievecargo test -p codex-app-server --lib map_epiphany_retrieve_response_preserves_summary_and_results
- full
cargo test -p codex-app-server-protocolpassed after restoring stable schema fixtures - after tracing the stack overflow from the richer promotion slice, full
cargo test -p codex-app-server --libnow passes 232/232 withCARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codexand repo-local Cargo config supplyingRUST_MIN_STACK=67108864
Important Windows footgun:
- the
v8crate blows up on cross-drive builds because it tries to create a Windows symlink during build setup - to test
codex-corereliably here, set:CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex
Without that, you get to learn about symlink_dir failed: ... A required privilege is not held by the client, which is not the kind of enlightenment we were after.
Recommended Next Implementation
Do not restart verification from superstition. The current Phase 4 retrieval/indexing/core-extraction baseline is already verified, committed, and pushed.
The durable state seam exists, the turn loop reads it, clients can load typed Epiphany state directly, the first retrieval slice is real, the explicit persistent-semantic indexing path is landed, the first distill/promote/update path is live-smoked, and promotion now has a first structural map/churn safety layer. The next clean move is richer observation-to-map proposal machinery, not pretending the already-shipped slices still need ceremony.
Current next implementation move:
- treat the live-smoked retrieval/indexing baseline, typed update surface, typed distill proposal surface, and typed promote gate as real
- keep the current env/default Qdrant/Ollama config surface for now
- keep
thread/epiphany/retrieveandthread/epiphany/distillread-only - build the next layer above the distill/promote/update surfaces:
- richer map/churn patch generation from verified observations
- promotion policy beyond structural validation only when the evidence path stays explicit
- verifier-backed acceptance/rejection evidence
- no GUI, watcher, or specialist-agent machinery yet
What Not To Do Next
Not yet:
- GUI work
- watcher-driven semantic invalidation
- automatic observation promotion
- specialist-agent scheduling
- user-facing activation flows
The next slice should stay small and mean:
- harden the explicit state-update path with a live app-server smoke when useful
- harden distillation only through explicit proposal/promotion checks, not hidden writes
- keep GUI, watcher mutation, and specialist-agent logic dark
Verification Commands
State sanity from the repo root:
& 'C:\Users\Meta\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe' '.\tools\epiphany_state.py' status
Get-Content -Tail 5 '.\state\evidence.jsonl'
git status --short
Targeted codex-core test pattern on this Windows machine:
cmd /c "\"C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Auxiliary\Build\vcvars64.bat\" >nul 2>&1 && set CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex && cd /d E:\Projects\EpiphanyAgent\vendor\codex\codex-rs && %USERPROFILE%\.cargo\bin\cargo.exe test -p codex-core --lib epiphany -- --list"
Short Version
The repo is in a good state.
Phase 1, Phase 2, and a minimal Phase 3 typed read surface are landed and verified. vendor/codex is first-class in the parent repo now. The next clean move is repo-local hybrid retrieval, not GUI paint and not another architectural detour. Also: pre-compaction persistence is now an explicit design rule, not a lucky habit.