Cut persistent state cruft
This commit is contained in:
parent
a0f030a216
commit
d62f4d596a
5 changed files with 188 additions and 803 deletions
|
|
@ -1,568 +1,125 @@
|
|||
# Fresh Workspace Handoff
|
||||
|
||||
## What This Repo Is
|
||||
This is the re-entry packet for `E:\Projects\EpiphanyAgent`.
|
||||
|
||||
`EpiphanyAgent` is a prototype workspace for upgrading AI coding harnesses so they stop confusing local motion with global understanding.
|
||||
It is intentionally short. Historical proof belongs in git and
|
||||
`state/evidence.jsonl`; exact control flow belongs in
|
||||
`notes/epiphany-current-algorithmic-map.md`; forward planning belongs in
|
||||
`notes/epiphany-fork-implementation-plan.md`.
|
||||
|
||||
The working idea is simple enough:
|
||||
## Rehydrate
|
||||
|
||||
- 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
|
||||
From the repo root:
|
||||
|
||||
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.
|
||||
```powershell
|
||||
& 'C:\Users\Meta\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe' '.\tools\epiphany_state.py' status
|
||||
Get-Content '.\state\map.yaml'
|
||||
Get-Content '.\notes\fresh-workspace-handoff.md'
|
||||
Get-Content '.\notes\epiphany-current-algorithmic-map.md'
|
||||
Get-Content '.\notes\epiphany-fork-implementation-plan.md'
|
||||
git status --short --branch
|
||||
git log --oneline -5
|
||||
Get-Content '.\state\evidence.jsonl' -Tail 8
|
||||
```
|
||||
|
||||
## Current Repo State
|
||||
Do not trust this file for the exact live HEAD. Always check git.
|
||||
|
||||
Important consequence:
|
||||
## Current Orientation
|
||||
|
||||
- `vendor/codex` is 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
|
||||
- Current branch before this cleanup pass: `main...origin/main [ahead 5]`.
|
||||
- Current HEAD before this cleanup pass: `a0f030a Distill Epiphany persistent state docs`.
|
||||
- Phase 1 through Phase 5 are complete enough.
|
||||
- Phase 6 has begun with read-only `thread/epiphany/scene`.
|
||||
- The repo is an Epiphany fork of Codex, not a Codex preset.
|
||||
- `vendor/codex` is tracked directly, not a submodule.
|
||||
- `epiphany-core` owns the heavy Epiphany organs where practical.
|
||||
|
||||
Recent anchor commits:
|
||||
## Landed Machine
|
||||
|
||||
- `2042687e3035c5a86d7f6aa66306d87abcc10f2d` - vendored Codex and landed the Phase 1 Epiphany core state slice
|
||||
- `c823815` - persisted the Phase 2 implementation plan and refreshed the project handoff/state
|
||||
- `efd1420` - landed and pushed the Phase 2 prompt-integration slice
|
||||
- `640e063` - documented the pre-compaction Epiphany workflow and synced the repo memory before compaction
|
||||
- `360dfea` - landed and pushed the Phase 4 hybrid retrieval slice
|
||||
- `80c29e0` - extracted Epiphany core organs into `epiphany-core`, landed explicit Qdrant indexing, and added licensing guardrails
|
||||
- `bb557d1` - hardened verifier-backed promotion for map/churn replacement patches
|
||||
- `fbd4dc2` - added repo-local app-server test stack configuration after tracing Windows stack pressure
|
||||
- `cabad31` - added experimental `thread/epiphany/stateUpdated` notifications after successful update/promote writes
|
||||
- `4c770e9` - labeled Epiphany state update notifications with typed `source` values
|
||||
- latest slice - hardened `thread/epiphany/stateUpdated` with event-level `revision` and typed `changedFields`
|
||||
- current slice - fixed accepted promotion notifications so `changedFields` always includes `evidence` when verifier evidence is appended, even if the accepted patch had no patch evidence
|
||||
- current slice - added response-level `revision` and `changedFields` to successful `thread/epiphany/update` and accepted `thread/epiphany/promote` responses
|
||||
- current slice - hardened the reusable Phase 5 smoke so rejected promotions explicitly prove `thread/epiphany/stateUpdated` stays silent
|
||||
- current slice - hardened direct `thread/epiphany/update` so malformed appended observations/evidence and structurally invalid replacement fields are rejected before mutation, and the reusable smoke proves invalid direct updates stay silent
|
||||
- current slice - aligned successful update/promote response and notification state payloads with the same client-visible live-state projection used by `thread/read`, including retrieval-summary backfill
|
||||
- current slice - added the first Phase 6 reflection surface as read-only `thread/epiphany/scene`, projecting objective, subgoals, invariant counts, graph focus, retrieval status, observations, evidence, churn, live/stored source, and available control actions from existing Epiphany state
|
||||
The current spine:
|
||||
|
||||
Do not trust this note for the exact current HEAD; use `git log --oneline -1` if you need the live commit.
|
||||
- durable `EpiphanyThreadState` in protocol/core session and rollout state
|
||||
- prompt injection through a bounded `<epiphany_state>` developer fragment
|
||||
- typed client read through `Thread.epiphanyState`
|
||||
- read-only hybrid retrieval through `thread/epiphany/retrieve`
|
||||
- explicit semantic indexing through `thread/epiphany/index`
|
||||
- durable state update through `thread/epiphany/update`
|
||||
- read-only observation distillation through `thread/epiphany/distill`
|
||||
- read-only map/churn proposal through `thread/epiphany/propose`
|
||||
- verifier-backed promotion through `thread/epiphany/promote`
|
||||
- successful-write notification through `thread/epiphany/stateUpdated`
|
||||
- read-only compact reflection through `thread/epiphany/scene`
|
||||
|
||||
Canonical project state still lives in:
|
||||
The exact current control flow is documented in
|
||||
`notes/epiphany-current-algorithmic-map.md`.
|
||||
|
||||
- `state/map.yaml`
|
||||
- `state/scratch.md`
|
||||
- `state/evidence.jsonl`
|
||||
## Boundaries
|
||||
|
||||
## Imminent Compact-Rehydrate-Reorient Packet
|
||||
- `thread/epiphany/retrieve` is read-only.
|
||||
- `thread/epiphany/distill` is read-only.
|
||||
- `thread/epiphany/propose` is read-only.
|
||||
- `thread/epiphany/scene` is read-only.
|
||||
- Durable typed state writes go through `thread/epiphany/update` or accepted `thread/epiphany/promote`.
|
||||
- `thread/epiphany/index` writes the retrieval catalog, not durable Epiphany understanding.
|
||||
- GUI/client surfaces reflect and steer typed state; they do not become the source of truth.
|
||||
- Do not restart Phase 5 hardening without a concrete regression.
|
||||
|
||||
If this thread compacts now, resume from this packet before doing implementation work. This packet supersedes older "post-Phase-5 hardening" guidance.
|
||||
## Verification Guardrails
|
||||
|
||||
Rehydrate:
|
||||
For Phase 5 control-plane behavior changes, run:
|
||||
|
||||
- run `tools/epiphany_state.py status`
|
||||
- read `state/map.yaml`
|
||||
- read this handoff
|
||||
- read `notes/epiphany-current-algorithmic-map.md`
|
||||
- read `notes/epiphany-fork-implementation-plan.md`
|
||||
- check `git status --short --branch` and `git log --oneline -5`
|
||||
- read the tail of `state/evidence.jsonl`
|
||||
```powershell
|
||||
& 'C:\Users\Meta\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe' '.\tools\epiphany_phase5_smoke.py'
|
||||
```
|
||||
|
||||
Reorient:
|
||||
For Codex Rust work on this Windows machine:
|
||||
|
||||
- current HEAD before this imminent-compaction packet was refreshed: `8507b3c Add Epiphany scene projection`
|
||||
- branch is `main...origin/main [ahead 3]` before this packet commit
|
||||
- current active lane is Phase 6 reflection boundary; the first read-only scene surface now exists
|
||||
- latest landed implementation slice: successful `thread/epiphany/update` and accepted `thread/epiphany/promote` responses/notifications now publish the same client-visible live-state projection as `thread/read`, including retrieval-summary backfill
|
||||
- latest landed Phase 6 slice: experimental `thread/epiphany/scene` derives a client-shaped reflection from `thread/read`-compatible Epiphany state without mutating or persisting anything
|
||||
- latest docs/memory slice: Phase 5 is marked complete enough; the plan, map, handoff, algorithmic map, AGENTS discipline, and evidence now warn against self-reinforcing "one more tiny hardening slice" handoffs
|
||||
- latest verification slice for the scene surface: `cargo fmt -p codex-app-server-protocol -p codex-app-server`; `cargo test -p codex-app-server-protocol --lib thread_epiphany_`; regenerated stable schema fixtures; `cargo test -p codex-app-server-protocol --test schema_fixtures`; `cargo test -p codex-app-server --lib map_epiphany_`; `cargo build -p codex-app-server`; `git diff --check`
|
||||
- richer Phase 5 smoke previously observed retrieval status `ready` on update/promote responses and notifications, with rejected promotions and invalid direct updates still silent/non-mutating
|
||||
- `thread/epiphany/retrieve`, `thread/epiphany/distill`, and `thread/epiphany/propose` remain read-only
|
||||
- accepted durable Epiphany writes must still route through `thread/epiphany/update` or verifier-backed `thread/epiphany/promote`
|
||||
- automatic runtime Compact-Rehydrate-Reorient-Continue coordination is not implemented; CRRC is currently enforced by repo-local state, handoff, evidence, and operating discipline
|
||||
```powershell
|
||||
$env:CARGO_TARGET_DIR='C:\Users\Meta\.cargo-target-codex'
|
||||
```
|
||||
|
||||
Continue:
|
||||
Do not parallelize cargo builds or tests against the same target directory.
|
||||
|
||||
- do not restart Phase 5 just because the handoff says to be careful; the update/distill/propose/promote/read/notification seam is complete enough unless a concrete regression appears
|
||||
- use `tools/epiphany_phase5_smoke.py` as the app-server seam guardrail before changing proposal/promotion/write/read behavior, not as a ritual for generating more tiny safety work
|
||||
- continue from the first Phase 6 scene-surface baseline; either live-smoke `thread/epiphany/scene` through app-server or move toward a minimal job-state/progress surface
|
||||
- avoid handoff notes that only say "next smallest hardening slice"; they can trap the next agent in furniture-rearrangement mode
|
||||
- likely next move: use the new scene surface as the thin typed read projection and decide whether to live-smoke it or add a minimal job-state/progress surface; do not implement from vibes
|
||||
- if you touch only the scene read surface, use focused scene/protocol/schema checks; run the full Phase 5 smoke only before changing proposal, promotion, update, read-projection, or notification behavior
|
||||
- before natural-language algorithm-map edits, reread the exact source being described
|
||||
- if a regression or benchmark fix attempt does not move the target, immediately revert that attempt before trying the next hypothesis
|
||||
For protocol changes, run focused protocol tests and regenerate stable schema
|
||||
fixtures only when the schema actually changed.
|
||||
|
||||
## Licensing State
|
||||
## Persistent State Hygiene
|
||||
|
||||
- the repo now has a top-level `LICENSE` file 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.md` or 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
|
||||
The latest cleanup pass cut persistent state cruft.
|
||||
|
||||
Current implementation plan note:
|
||||
Rules now in force:
|
||||
|
||||
- `notes/epiphany-fork-implementation-plan.md`
|
||||
- `state/map.yaml` is canonical current truth.
|
||||
- `state/scratch.md` is disposable scratch.
|
||||
- `state/evidence.jsonl` is durable event history.
|
||||
- this handoff is a compact re-entry packet.
|
||||
- `notes/epiphany-fork-implementation-plan.md` is the distilled forward plan.
|
||||
- `notes/epiphany-core-harness-surfaces.md` is the stable surface contract.
|
||||
- `notes/epiphany-current-algorithmic-map.md` is the source-grounded control-flow map.
|
||||
|
||||
Current architectural/spec notes:
|
||||
Do not let any one note become all of those things. That is how the tower grows
|
||||
sideways and starts calling itself architecture.
|
||||
|
||||
- `notes/codex-repository-algorithmic-map.md`
|
||||
- `notes/epiphany-current-algorithmic-map.md`
|
||||
- `notes/epiphany-core-harness-surfaces.md`
|
||||
## Next Real Move
|
||||
|
||||
## Current Landed Baseline
|
||||
Do not continue implementation automatically from a rehydrate-only request.
|
||||
|
||||
Phase 4 repo-local hybrid retrieval is now landed on `main`. The first retrieval anchor is `360dfea`; `80c29e0` adds explicit Qdrant indexing, the `epiphany-core` extraction, and licensing guardrails. Later `main` also includes the typed update/distill/promote surfaces, promotion safety layer, and app-server stack-pressure fix. This is no longer a vague scaffold, a maybe, or a working-tree-only event.
|
||||
When the user asks to continue, choose one Phase 6 organ:
|
||||
|
||||
Current verified baseline after that first retrieval anchor:
|
||||
1. Live-smoke `thread/epiphany/scene` through app-server.
|
||||
2. Design and land a minimal read-only job/progress reflection surface for indexing, remap, and verification work.
|
||||
|
||||
- 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/retrieve` with BM25 fallback still intact
|
||||
- repo-owned `epiphany-core` extraction for the heavy prompt/replay/retrieval organ, leaving vendored Codex with thin adapters plus the typed host seam
|
||||
The scene-smoke path is the tighter next step. The job/progress path is the
|
||||
larger missing organ.
|
||||
|
||||
Current verified typed state/promotion layer:
|
||||
|
||||
- experimental loaded-thread-only `thread/epiphany/update`
|
||||
- experimental loaded-thread-only `thread/epiphany/distill`
|
||||
- experimental loaded-thread-only `thread/epiphany/promote`
|
||||
- experimental loaded-thread-only `thread/epiphany/propose`
|
||||
- experimental `thread/epiphany/stateUpdated` notifications after successful direct updates and accepted promotions, with typed `source` values of `update` or `promote`, event-level `revision`, and typed `changedFields`
|
||||
- response-level `revision` and `changedFields` on successful `thread/epiphany/update` and accepted `thread/epiphany/promote`
|
||||
- successful update/promote response and notification state payloads now include the same non-durable retrieval-summary backfill that live `thread/read` exposes when durable Epiphany state lacks persisted retrieval metadata
|
||||
- experimental read-only `thread/epiphany/scene`, which turns existing authoritative Epiphany state into a compact client reflection without writing state or creating a GUI-owned brain
|
||||
- typed patch shape for observations, evidence, objective, subgoals, invariants, graphs, graph frontier/checkpoint, scratch, churn, and mode
|
||||
- direct `thread/epiphany/update` validation for appended observations/evidence and replacement fields: append records need nonempty identity fields, patch ids cannot duplicate or reuse durable ids, observations must cite existing or same-patch evidence ids, and graph/frontier/checkpoint/subgoal/churn replacement shapes must pass the shared `epiphany-core` structural validator before the durable writer mutates state
|
||||
- deterministic observation/evidence proposal generation in `epiphany-core`
|
||||
- observation distillation now keeps noisy tool/command/shell/model output bounded by selecting salient output lines, prioritizing final result/failure/error/finished lines above generic warnings, and defaulting evidence kind to `tool-output` or `model-output` when the caller did not provide one
|
||||
- deterministic map/churn proposal generation in `epiphany-core`, now with first-pass graph-node reuse by exact code-ref, same-path overlap, or deterministic path-node id before new candidate nodes are created, strict semantic reuse for unanchored architecture nodes, linked frontier focus through graph links and named incident edges, evidence-backed selected observations via accepting `recent_evidence`, selected-observation prioritization, automatic bounded observation selection when ids are omitted, and match-kind-aware churn pressure derived from exact-ref refinement, same-path broadening, deterministic-node reuse, semantic anchoring, or new candidate surfaces
|
||||
- verifier-backed promotion policy evaluation in `epiphany-core`, now rejecting risky churn deltas unless they carry explicit warning rationale and strong verifier evidence kind; graph expansion is risky even if a patch understates `diff_pressure`, and strong verifier kinds are token-matched instead of substring-matched
|
||||
- core `CodexThread.epiphany_update_state(...)` applies the patch to live `SessionState`, bumps revision, persists `RolloutItem::EpiphanyState`, and flushes rollout
|
||||
- app-server now returns response-level `revision` and `changedFields` from successful direct update and accepted promotion calls, and emits `thread/epiphany/stateUpdated` after the direct update path and after accepted promotion return an updated state; notifications identify their `source`, expose event-level `revision`, list typed `changedFields`, publish the same retrieval-summary-backed client-visible state projection as `thread/read`, and the richer smoke now explicitly proves rejected promotions plus invalid direct append/replacement updates still do not mutate state or emit an update notification
|
||||
- replay helpers in both `codex-core` and `epiphany-core` accept 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-c780bee59a68` rooted at `E:\Projects\EpiphanyAgent\epiphany-core`
|
||||
- called `thread/epiphany/update` with `expectedRevision: 0`
|
||||
- response revision was `1`
|
||||
- `thread/read` returned `epiphanyState.revision == 1`, objective `Smoke-test explicit Epiphany update persistence`, observation `obs-update-smoke`, and evidence `ev-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-65b072cc2cca` rooted at `E:\Projects\EpiphanyAgent\epiphany-core`
|
||||
- called `thread/epiphany/distill` with `sourceKind: smoke`, `status: ok`, subject `thread/epiphany/distill`, text, and a code ref to `src/distillation.rs`
|
||||
- distill returned `expectedRevision: 0` plus observation `obs-c9bfcac23d66` and evidence `ev-c9bfcac23d66` in a patch
|
||||
- passing that patch to `thread/epiphany/update` advanced state to revision `1`
|
||||
- `thread/read` returned the generated observation/evidence ids in `epiphanyState`
|
||||
- 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-2487a591ef7a` rooted at `E:\Projects\EpiphanyAgent\epiphany-core`
|
||||
- distilled a promotion smoke patch
|
||||
- `thread/epiphany/promote` rejected failed verifier evidence with `accepted: false`, a rejection reason, and no `epiphanyState`
|
||||
- `thread/read` after rejection had no Epiphany state, proving rejection did not mutate state
|
||||
- `thread/epiphany/promote` accepted verifier evidence with status `ok`, appended verifier evidence, and applied through the durable update path
|
||||
- `thread/read` returned revision `1`, observation `obs-77248505f492`, patch evidence `ev-77248505f492`, and verifier evidence `ev-promote-smoke-verifier`
|
||||
- smoke result lives at `.epiphany-smoke/promote-smoke-result.json`
|
||||
|
||||
Live smoke after the pushed baseline:
|
||||
|
||||
- built `codex-app-server.exe` with `CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex`
|
||||
- used an isolated `CODEX_HOME` at `.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/index` against real local Qdrant/Ollama returned ready state with 5 indexed files and 198 chunks
|
||||
- Qdrant collection `epiphany_workspace_fa24bab116f8d229` was created
|
||||
- `thread/epiphany/retrieve` returned persistent semantic chunks from `src/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.toml`
|
||||
- `epiphany-core/src/prompt.rs`
|
||||
- `epiphany-core/src/rollout.rs`
|
||||
- `epiphany-core/src/retrieval.rs`
|
||||
- `epiphany-core/src/lib.rs`
|
||||
- `vendor/codex/codex-rs/protocol/src/protocol.rs`
|
||||
- `vendor/codex/codex-rs/core/src/epiphany_retrieval.rs`
|
||||
- `vendor/codex/codex-rs/core/src/epiphany_rollout.rs`
|
||||
- `vendor/codex/codex-rs/core/src/context/epiphany_state_instructions.rs`
|
||||
- `vendor/codex/codex-rs/core/src/codex_thread.rs`
|
||||
- `vendor/codex/codex-rs/core/src/lib.rs`
|
||||
- `vendor/codex/codex-rs/core/Cargo.toml`
|
||||
- `vendor/codex/codex-rs/core/src/session/rollout_reconstruction.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/rollout_reconstruction_tests.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/tests.rs`
|
||||
- `vendor/codex/codex-rs/app-server-protocol/src/protocol/common.rs`
|
||||
- `vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs`
|
||||
- `vendor/codex/codex-rs/app-server-protocol/src/export.rs`
|
||||
- `vendor/codex/codex-rs/app-server/src/codex_message_processor.rs`
|
||||
- `vendor/codex/codex-rs/app-server/README.md`
|
||||
- regenerated stable fixtures under `vendor/codex/codex-rs/app-server-protocol/schema/`
|
||||
|
||||
What is wired right now:
|
||||
|
||||
- `EpiphanyThreadState` already has retrieval metadata fields and types in protocol
|
||||
- repo-owned `epiphany-core` now 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-core` now keeps thin adapters at:
|
||||
- `core/src/epiphany_retrieval.rs`
|
||||
- `core/src/epiphany_rollout.rs`
|
||||
- `core/src/epiphany_distillation.rs`
|
||||
- `core/src/epiphany_promotion.rs`
|
||||
- `core/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
|
||||
- `CodexThread` now 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/propose`
|
||||
- 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/distill` is the first read-only proposal surface; it returns an `expectedRevision` plus a patch and requires explicit promotion through `thread/epiphany/update`
|
||||
- `thread/epiphany/propose` is the first read-only map/churn proposal surface; it uses caller-supplied observation ids or auto-selects a bounded coherent path cluster from verified observations with accepting `recent_evidence` and code refs, focuses existing architecture graph nodes when refs overlap, creates new candidate path nodes only for unmapped surfaces, follows graph links into related architecture/dataflow nodes, marks named incident graph edges active, derives churn pressure from the proposal shape, and returns replacement graphs/frontier/churn for explicit promotion
|
||||
- `thread/epiphany/promote` is the first explicit promotion gate; it rejects failed verifier evidence without mutation and applies accepted candidates through the update path
|
||||
- `thread/epiphany/promote` now 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 called
|
||||
- `thread/epiphany/update` is the first explicit durable Epiphany state write surface; it rejects empty patches, supports optional revision matching, validates appended observations/evidence and structural replacement fields, appends valid observations/evidence, replaces bounded typed fields, increments state revision, and persists immediately
|
||||
- `thread/epiphany/stateUpdated` is the first live typed-state notification surface; it fires only after successful `thread/epiphany/update` and accepted `thread/epiphany/promote`, carrying the full updated client-visible `epiphanyState`, event-level `revision`, typed `changedFields`, plus `source: "update"` or `source: "promote"`; the direct update/promote responses also return `revision` and `changedFields`, and all successful write response/notification states now use the same retrieval-summary backfill as `thread/read`
|
||||
- live hydrated `thread.epiphanyState` reads 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-core` already depends on `bm25`
|
||||
- `vendor/codex/codex-rs/core/src/tools/handlers/tool_search.rs` already shows how BM25 is used in-tree
|
||||
- tracked corpus preflight for `vendor/codex/codex-rs` at `vendor/codex` HEAD `d45ab10` is `3642` files / `31.09 MB`
|
||||
- raw working-tree size under `codex-rs` is 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_search` for 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.toml` passed
|
||||
- `cargo test --manifest-path E:\Projects\EpiphanyAgent\epiphany-core\Cargo.toml` passed
|
||||
- `cargo fmt --all` passed
|
||||
- `cargo test -p codex-core -p codex-app-server-protocol -p codex-app-server --lib --no-run` passed with `CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex`
|
||||
- targeted Phase 4 tests passed:
|
||||
- `cargo test -p codex-core --lib epiphany`
|
||||
- `cargo 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-protocol` passed after regenerating stable schema fixtures
|
||||
|
||||
Notable verification fixes:
|
||||
|
||||
- `codex_message_processor.rs` needed the live-thread retrieval helper call to stop pretending `&CodexThread` needed `.as_ref()`
|
||||
- `core/src/session/tests.rs` needed `retrieval: None` in the prompt fixture Epiphany state
|
||||
- the exact-hit retrieval test fixture needed a genuinely matchable file name (`session_checkpoint.rs`)
|
||||
- `EpiphanyThreadState` needed 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 -- --experimental` rewrites 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/retrieve` just 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)` exists
|
||||
- `SessionState` stores `epiphany_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.rs`
|
||||
- `vendor/codex/codex-rs/core/src/state/session.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/mod.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/rollout_reconstruction.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/tests.rs`
|
||||
- `vendor/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`:
|
||||
|
||||
- `EpiphanyStateInstructions` renders a bounded developer fragment from `EpiphanyThreadState`
|
||||
- the fragment is wrapped in `<epiphany_state> ... </epiphany_state>`
|
||||
- `Session::build_initial_context` injects it immediately after collaboration-mode instructions when `SessionState.epiphany_state` exists
|
||||
- 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.rs`
|
||||
- `vendor/codex/codex-rs/core/src/context/mod.rs`
|
||||
- `vendor/codex/codex-rs/core/src/context/epiphany_state_instructions.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/mod.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/tests.rs`
|
||||
- `vendor/codex/codex-rs/core/src/session/snapshots/codex_core__session__build_initial_context_epiphany_state.snap`
|
||||
- `vendor/codex/codex-rs/protocol/src/protocol.rs`
|
||||
|
||||
Phase 3 is landed too, in a conservative read-surface form.
|
||||
|
||||
What landed:
|
||||
|
||||
- app-server protocol `Thread` payloads now expose optional typed `epiphany_state`
|
||||
- hydrated thread responses prefer live `CodexThread` state 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.rs`
|
||||
- `vendor/codex/codex-rs/core/src/epiphany_rollout.rs`
|
||||
- `vendor/codex/codex-rs/core/src/lib.rs`
|
||||
- `vendor/codex/codex-rs/core/src/codex_thread.rs`
|
||||
- `vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs`
|
||||
- `vendor/codex/codex-rs/app-server-protocol/src/protocol/common.rs`
|
||||
- `vendor/codex/codex-rs/app-server/src/codex_message_processor.rs`
|
||||
- `vendor/codex/codex-rs/app-server/README.md`
|
||||
- compatibility fixture/test updates in `analytics`, `exec`, and `tui`
|
||||
|
||||
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/codex` is ordinary tracked repo content, not a submodule.
|
||||
- Phase 2 means Codex now **reads** Epiphany state during turn construction:
|
||||
- `SessionState.epiphany_state` is the internal activation signal
|
||||
- `Session::build_initial_context` injects 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 `Thread` payloads:
|
||||
- `thread/start`, `thread/resume`, `thread/fork`, `thread/read`, `thread/unarchive`, and detached review-thread startup can carry `thread.epiphanyState` when present
|
||||
- loaded threads use live state
|
||||
- stored thread reads reconstruct from rollout with the same rollback/compaction semantics as core
|
||||
- Phase 4 repo-local retrieval/indexing is landed:
|
||||
- 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`
|
||||
- Phase 5 semantic distillation/promotion is active:
|
||||
- dedicated experimental `thread/epiphany/update`, `thread/epiphany/distill`, and `thread/epiphany/promote` exist and are live-smoked
|
||||
- experimental `thread/epiphany/stateUpdated` now exists and is live-smoked for both direct update and accepted promote paths, including source labels, event-level revision, typed changed fields, and retrieval-summary-backed state projection; successful update/promote responses now mirror revision, changed fields, and the same client-visible state projection too
|
||||
- structural map/churn promotion validation is landed in `epiphany-core`
|
||||
- proposal selection now rejects observations without accepting `recent_evidence`, and churn pressure now reflects match-kind-aware map-delta shape
|
||||
- proposal can now omit `observationIds` and let `epiphany-core` choose a bounded coherent path cluster from existing verified, evidence-backed observations using source/evidence quality plus graph-frontier focus
|
||||
- proposal churn now distinguishes exact-ref refinements from same-path broadening, deterministic-node reuse, semantic unanchored-node reuse, and new candidate surfaces before setting graph freshness and diff pressure
|
||||
- distillation now summarizes noisy tool/command/shell/model output into salient typed evidence rather than preserving raw output sludge as the summary, and final result/failure/error/finished lines outrank generic warnings unless warning is the only central signal
|
||||
- promotion now rejects medium/high/expanded/broadening/semantic/update churn deltas that lack a warning, carry weak generic verifier evidence, or rely on substring verifier-kind accidents such as `contest`
|
||||
- richer Phase 5 app-server smoke is now reproducible through `tools/epiphany_phase5_smoke.py`; it verifies `shell-tool` distillation to `tool-output`, read-only proposal, update notification source/revision/changed-fields `update`/1/`observations,evidence`, verifier-only accepted promotion notification source/revision/changed-fields `promote`/2/`observations,evidence`, invalid direct observation/evidence update rejection with unchanged revision and no state update notification, invalid direct replacement update rejection with unchanged revision and no state update notification, risky-churn rejection without warning, expanded-low-pressure rejection, substring verifier-kind rejection, weak verifier-kind rejection, accepted promotion only with warning plus strong verifier evidence, and graph/churn promote notification source/revision/changed-fields `promote`/3/`graphs,graphFrontier,observations,evidence,churn`
|
||||
- the Epiphany algorithmic map has been semantically audited flow-by-flow against the cited code; stale line anchors were fixed, and the current typed spine still describes a coherent machine
|
||||
- the next bounded follow-up should use the richer smoke harness as a guardrail before the next source-grounded proposal/promotion hardening slice
|
||||
- There is now a first live `thread/epiphany/stateUpdated` notification seam for successful update/promote writes; it includes source, revision, and changed-field metadata, but there is still no broader watcher/job/specialist event stream.
|
||||
- The next phase is **not** GUI work.
|
||||
- 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 `main` and 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 --experimental` is 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
|
||||
- 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-codex` for `codex-core` work on this machine
|
||||
- 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.toml` now sets `RUST_MIN_STACK=67108864`
|
||||
- boxed-future request-dispatch experiments were tested and removed; the Cargo stack config is the minimal verified fix
|
||||
- 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:
|
||||
|
||||
1. before compaction, phase boundaries, or handoff:
|
||||
- sync the canonical map
|
||||
- append evidence
|
||||
- refresh the handoff note
|
||||
- make the next action explicit
|
||||
2. 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
|
||||
3. compaction should happen from a known checkpoint, not at some random point in the middle of an implementation trance
|
||||
4. 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.
|
||||
|
||||
Regression and benchmark discipline:
|
||||
|
||||
- if a change is made to fix a regression or move a benchmark and it does not fix that regression or move that benchmark, revert it immediately
|
||||
- do not let failed hypotheses accumulate as maybe-useful scaffolding
|
||||
- record the rejected path when the lesson matters, then try the next bounded hypothesis from a clean diff
|
||||
- this is also rendered by `epiphany-core::render_epiphany_state(...)` in hydrated Epiphany developer context, because runtime harness pressure beats wall art
|
||||
|
||||
## 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-protocol`
|
||||
- `codex-app-server-protocol`
|
||||
- `codex-rollout`
|
||||
- `codex-state`
|
||||
- targeted new `codex-core` Epiphany persistence/replay tests passed
|
||||
- targeted `codex-core` `epiphany` tests passed after Phase 2
|
||||
- broader `codex-core` `build_initial_context_*` coverage passed after Phase 2
|
||||
- `cargo fmt --all` passed again after Phase 3
|
||||
- `cargo test -p codex-core -p codex-app-server-protocol -p codex-app-server -p codex-analytics -p codex-exec -p codex-tui --lib --no-run` passed after the new `Thread.epiphanyState` field fallout was patched
|
||||
- targeted Phase 3 tests passed:
|
||||
- `cargo test -p codex-core --lib latest_epiphany_state_from_rollout_items`
|
||||
- `cargo test -p codex-app-server --lib load_epiphany_state_from_rollout_path_reads_latest_snapshot`
|
||||
- `cargo test -p codex-app-server-protocol --lib serialize_client_response`
|
||||
- `cargo fmt --all` passed for the Phase 4 retrieval slice
|
||||
- `cargo test -p codex-core -p codex-app-server-protocol -p codex-app-server --lib --no-run` passed for the Phase 4 retrieval slice when `CARGO_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_retrieve`
|
||||
- `cargo test -p codex-app-server --lib map_epiphany_retrieve_response_preserves_summary_and_results`
|
||||
- full `cargo test -p codex-app-server-protocol` passed after restoring stable schema fixtures
|
||||
- after tracing the stack overflow from the richer promotion slice, full `cargo test -p codex-app-server --lib` now passes 232/232 with `CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex` and repo-local Cargo config supplying `RUST_MIN_STACK=67108864`; the temporary boxed-future request-dispatch experiments were removed after config-only verification passed
|
||||
|
||||
Important Windows footgun:
|
||||
|
||||
- the `v8` crate blows up on cross-drive builds because it tries to create a Windows symlink during build setup
|
||||
- to test `codex-core` reliably 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. Phase 4 retrieval/indexing/core-extraction is already verified, committed, and pushed. Phase 5 distill/propose/promote/update, the first structural promotion safety layer, graph-node reuse, linked frontier focus, evidence-backed proposal selection, selected-observation prioritization, strict unanchored-node semantic reuse, automatic bounded observation selection, match-kind-aware map-delta churn pressure, source-output-aware distillation, risky-delta promotion policy, expansion-freshness promotion hardening, token-aware verifier-kind promotion hardening, and the reusable richer app-server smoke harness are also landed.
|
||||
|
||||
The durable state seam exists, the turn loop reads it, clients can load typed Epiphany state directly, successful writes now publish a live typed `thread/epiphany/stateUpdated` notification, the first retrieval slice is real, the explicit persistent-semantic indexing path is landed, the distill/propose/promote/update path is live-smoked, promotion now has a first structural map/churn safety layer and risky-delta policy with token-aware verifier-kind matching, distillation summarizes noisy source output into typed evidence, and proposal now reuses existing architecture nodes before creating new path nodes, expands frontier focus through linked graph context, rejects selected observations without accepting recent evidence, prioritizes stronger selected observations for proposal wording, can reuse unanchored architecture nodes through strict semantic overlap, can auto-select a bounded evidence-backed observation cluster when ids are omitted, and reports match-kind-aware churn pressure from the proposal shape. The richer Phase 5 chain has now been smoke-tested through app-server and captured as a reusable tool instead of a one-off ritual.
|
||||
|
||||
Phase transition rule:
|
||||
|
||||
1. treat the live-smoked retrieval/indexing baseline as Phase 4 and the typed update/distill/propose/promote/read/notification control plane as the complete-enough Phase 5 baseline
|
||||
2. keep the current env/default Qdrant/Ollama config surface for now
|
||||
3. keep `thread/epiphany/retrieve`, `thread/epiphany/distill`, and `thread/epiphany/propose` read-only
|
||||
4. run `tools/epiphany_phase5_smoke.py` before changing proposal, promotion, update, read, or notification behavior
|
||||
5. do not keep adding tiny Phase 5 hardening rules merely because the harness can; if there is no concrete bug or real-use gap, move outward
|
||||
6. continue the Phase 6 reflection boundary from the new read-only `thread/epiphany/scene` baseline, or add a minimal job-state/progress surface that lets clients inspect long-running work without becoming the source of truth
|
||||
|
||||
## What Not To Do Next
|
||||
|
||||
Not yet:
|
||||
## Not Yet
|
||||
|
||||
- watcher-driven semantic invalidation
|
||||
- automatic observation promotion
|
||||
- specialist-agent scheduling
|
||||
- user-facing activation flows
|
||||
- GUI-as-source-of-truth
|
||||
- automatic runtime CRRC coordinator
|
||||
- broad event stream beyond the landed state update notification
|
||||
|
||||
Do not let caution write the roadmap by accident:
|
||||
|
||||
- no more generic "next smallest hardening slice" handoffs without naming the larger organ being advanced
|
||||
- no more Phase 5 furniture rearrangement unless a concrete failing smoke, bug, or real-use gap demands it
|
||||
- no GUI-as-source-of-truth work
|
||||
- no broad watcher mutation or specialist-agent logic yet
|
||||
- GUI/reflection work is allowed only as a thin view/control surface over already-authoritative typed state
|
||||
|
||||
## Verification Commands
|
||||
|
||||
State sanity from the repo root:
|
||||
|
||||
```powershell
|
||||
& '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
|
||||
& 'C:\Users\Meta\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe' '.\tools\epiphany_phase5_smoke.py'
|
||||
```
|
||||
|
||||
Targeted `codex-core` test pattern on this Windows machine:
|
||||
|
||||
```powershell
|
||||
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, the minimal Phase 3 typed read surface, Phase 4 retrieval/indexing/core-extraction, and the Phase 5 distill/propose/promote/update/read/notification control plane are landed and verified enough to move on. The first Phase 6 reflection-boundary slice is now present as read-only `thread/epiphany/scene`, a compact client projection over authoritative Epiphany state. `vendor/codex` is first-class in the parent repo now, with the heavier Epiphany organs living in `epiphany-core`. Successful direct updates and accepted promotions now return response-level revision/changed-field metadata and emit experimental `thread/epiphany/stateUpdated` notifications carrying the updated client-visible typed state, source labels, event-level revision, and typed changed fields; accepted promotion responses/notifications include `evidence` whenever verifier evidence is appended, even when patch evidence was empty, and successful write response/notification states include the same retrieval-summary backfill exposed by live `thread/read`. Direct updates reject malformed appended observations/evidence and structurally invalid replacement fields before mutation. Read-only distillation summarizes noisy tool/model output into typed evidence, read-only proposal can auto-select a bounded evidence-backed observation cluster and report match-kind-aware map-delta pressure, and promotion rejects risky deltas without warning plus strong verifier evidence. The current Epiphany algorithmic map has been source-audited against the code flow it describes. The richer Phase 5 chain is live-smoked through app-server by `tools/epiphany_phase5_smoke.py`. The next clean move is to use or extend the Phase 6 scene boundary, not to restart Phase 5 sanding unless a concrete regression appears. Pre-compaction persistence is now an explicit design rule, but persistence notes must name the next organ instead of trapping the agent in endless incremental hardening.
|
||||
The machine is good enough to move outward. Do not sand the same edge until the
|
||||
wood disappears.
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
"state/scratch.md",
|
||||
"state/evidence.jsonl"
|
||||
],
|
||||
"notes": "Initial scaffold plus tiny CLI. No evaluated task yet."
|
||||
"notes": "Active mainline. Phase 1-5 are complete enough; Phase 6 reflection has begun. Persistent state is now intentionally distilled rather than append-only."
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -161,3 +161,4 @@
|
|||
{"ts": "2026-04-25T15:07:22+00:00", "type": "verification", "status": "ok", "note": "Verified Phase 6 scene slice with cargo fmt -p codex-app-server-protocol -p codex-app-server, cargo test -p codex-app-server-protocol --lib thread_epiphany_, cargo test -p codex-app-server-protocol --test schema_fixtures after regenerating stable fixtures, cargo test -p codex-app-server --lib map_epiphany_, cargo build -p codex-app-server, and git diff --check."}
|
||||
{"ts": "2026-04-25T15:16:30+00:00", "type": "verification", "status": "ok", "note": "Prepared imminent CRRC packet after Phase 6 scene projection. Current HEAD before this packet commit is 8507b3c on main, branch is ahead of origin/main by 3, worktree was clean before packet refresh, and next task should rehydrate from map/handoff/evidence then either live-smoke thread/epiphany/scene or move to a minimal job-state/progress surface without restarting Phase 5 hardening."}
|
||||
{"ts": "2026-04-25T15:30:58+00:00", "type": "decision", "status": "ok", "note": "Cleaned persistent state cruft after comparing the implementation plan and harness-surfaces notes against their creation lineage. Replaced append-only micro-slice accumulation with distilled current-truth docs: implementation plan now carries baseline, boundaries, learned state-hygiene rule, next unknowns, and Phase 6 direction; harness surfaces now carries the stable surface contract, write/reflection authority, missing surfaces, job/progress direction, CRRC boundary, and persistent-state hygiene checklist."}
|
||||
{"ts": "2026-04-25T15:37:18+00:00", "type": "decision", "status": "ok", "note": "Performed a second Perfect Machine persistent-state audit. Found stale Phase 5 scratch, an overgrown fresh-workspace handoff, and an accepted-design map that had become a micro-slice ledger. Distilled state/map.yaml into canonical current truth, replaced scratch with disposable current audit notes, rewrote fresh-workspace-handoff.md as a compact re-entry packet, and updated branches.json so persistent state rehydrates sharper instead of larger."}
|
||||
|
|
|
|||
162
state/map.yaml
162
state/map.yaml
|
|
@ -1,137 +1,105 @@
|
|||
experiment:
|
||||
name: EpiphanyAgent
|
||||
status: scaffolded
|
||||
status: active
|
||||
phase: phase_6_reflection_boundary
|
||||
premise: >
|
||||
Test whether separating map, scratch, and output reduces architectural drift
|
||||
for coding tasks when using a strong general model.
|
||||
Test whether explicit typed state, maps, scratch, evidence, and ruthless
|
||||
state hygiene reduce architectural drift in AI coding work.
|
||||
|
||||
objective:
|
||||
primary: >
|
||||
Build Epiphany as an opinionated fork of Codex that forces models to keep
|
||||
explicit typed models of the codebase, active goal, evidence, and change
|
||||
machinery they are working on.
|
||||
immediate:
|
||||
- Finish the initial workspace scaffold.
|
||||
- Keep controller actions and write rules explicit.
|
||||
- Ground the Epiphany fork architecture against the real Codex codebase.
|
||||
- Use the first minimal runner or manual operating loop on a small real task.
|
||||
- Try the protocol on a small real task.
|
||||
current: >
|
||||
Grow Phase 6 reflection and observability from the landed typed state
|
||||
spine without letting GUI/client state become authoritative.
|
||||
|
||||
constraints:
|
||||
- No frontier-scale training budget.
|
||||
- Start with external state and prompting.
|
||||
- Keep the protocol light enough to use during normal work.
|
||||
- Prefer evidence over vibes.
|
||||
- Keep Codex as the host seam and `epiphany-core` as the repo-owned heavy organ where practical.
|
||||
- Keep persistent state small enough to rehydrate from without drowning the next agent.
|
||||
|
||||
invariants:
|
||||
- The map is canonical and slow-changing.
|
||||
- Scratch is temporary and allowed to be wrong.
|
||||
- Scratch is temporary and disposable.
|
||||
- Evidence is durable and append-only.
|
||||
- Output must not silently redefine the map.
|
||||
- Accepted changes should have recorded evidence.
|
||||
- Rejected paths stay recorded.
|
||||
- Algorithmic-map natural language and metaphors must be grounded in freshly read source context and concrete code references.
|
||||
- Rejected paths stay recorded when the lesson matters.
|
||||
- Algorithmic-map prose and metaphor must be grounded in freshly read source context and concrete code references.
|
||||
- Persistent state cruft is the same failure class as code cruft.
|
||||
|
||||
data_flow:
|
||||
observe:
|
||||
- task request
|
||||
- repository state
|
||||
- typed Epiphany state
|
||||
- verifier results
|
||||
process:
|
||||
- update map only with stable understanding
|
||||
- think about one subgoal at a time
|
||||
- propose one bounded change
|
||||
- verify against task goals and invariants
|
||||
- rehydrate from canonical state
|
||||
- reason over one bounded subgoal
|
||||
- modify only the surface that deserves to exist
|
||||
- verify the seam that matters
|
||||
- record evidence
|
||||
- commit or backtrack
|
||||
cut:
|
||||
- revert failed code hypotheses immediately
|
||||
- distill obsolete state instead of preserving it as context
|
||||
- move historical proof to git and evidence rather than plan prose
|
||||
|
||||
active_subgoals:
|
||||
- Treat the Phase 5 distill/propose/promote/update control plane as complete enough unless a concrete regression appears.
|
||||
- Keep vendored Codex as a thin typed host seam while Epiphany-owned prompt and retrieval/indexing logic live in the repo-owned `epiphany-core` crate.
|
||||
- Preserve exact/path lookup and BM25 fallback while the Qdrant path stays explicit and bounded.
|
||||
- Continue Phase 6 by growing the new read-only scene/reflection surface over authoritative Epiphany state without turning GUI/client state into the source of truth.
|
||||
- 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, and scene.
|
||||
- Continue Phase 6 from the read-only `thread/epiphany/scene` baseline.
|
||||
- Decide whether the next real organ is live scene smoke or minimal job/progress reflection.
|
||||
- Keep persistent project state ruthlessly distilled so rehydration strengthens the next turn instead of bloating it.
|
||||
|
||||
accepted_design:
|
||||
- external typed state files
|
||||
- bounded controller actions
|
||||
- verifier-guided acceptance
|
||||
- manual first, automation later
|
||||
- patch Codex via collaboration-mode presets before touching protocol enums
|
||||
- make Phase 1 preset selection, labeling, and instruction lookup preset-name-aware where needed because Epiphany initially rides on ModeKind::Default
|
||||
- for a GUI-centered experiment, build a dedicated wrapper around customized vendored Codex instead of adopting third-party OpenCodex forks
|
||||
- treat Epiphany as core-owned structured thread state in Codex, with the GUI as a reflection and steering layer rather than the source of truth
|
||||
- represent the Epiphany machine map as two linked graphs (architecture and dataflow) with rich natural-language node fields such as purpose, mechanism, and metaphor, plus line-anchored code references
|
||||
- make the graph model compaction-aware: preserve a durable spine, checkpoint and reselect a frontier, and allow scratch to be rewritten or discarded
|
||||
- for mapping work, distinguish a completed pass from actual understanding: require representative concrete transformation questions, record unresolved mechanism gaps durably, and carry those gates across compaction
|
||||
- treat Epiphany as a supervising harness over specialist agents sharing a typed state plane, with private role-scoped scratch by default and explicit ownership for map, evidence, and code-change domains
|
||||
- add a repo-local hybrid retrieval subsystem to Epiphany: combine exact path/symbol/lexical search with semantic chunk retrieval and graph-linked lookup, shard it by repo/subsystem, and track freshness from diffs
|
||||
- treat Codex's existing file watcher, subagent lifecycle, memory pipeline, and diff stream as reusable substrate, but add the missing semantic layer above them: typed repo understanding, freshness invalidation, structured tool-output distillation, and shared state across specialist agents
|
||||
- insert a structured observation layer between raw tool output and durable Epiphany state so evidence, invalidation, and graph updates are promoted from typed distillation rather than transcript osmosis
|
||||
- design Epiphany as GUI-first rather than transcript-first: the primary artifact is typed thread state, chat is one client of that state, user steering should go through typed updates, and long-running retrieval/remap/verification work should surface as explicit observable jobs
|
||||
- treat compaction as a role-specific state transition with safe points, explicit checkpoints, and resume packets; workers may compact aggressively between implementation passes, while mapper, verifier, and coordinator preserve different state at different boundaries
|
||||
- make the compact-rehydrate-continue cycle an explicit Epiphany architecture primitive: compact only from a checkpoint when possible, rehydrate from canonical map/handoff/evidence, restate the persisted next action, then continue with one bounded move
|
||||
- preserve handoff context in repo-local AGENTS and notes files
|
||||
- keep a durable repository-level algorithmic map of vendored Codex so GUI and Epiphany changes hook into the existing app-server/core boundary instead of reimplementing the turn loop
|
||||
- keep a dedicated Epiphany algorithmic map that documents the currently landed fork architecture separately from the full Codex machine map and the future-facing harness spec
|
||||
- keep the Codex algorithmic map honest about auxiliary side channels and limitations: file watching, unified diffs, compaction, subagent messaging, and memory summarization are real substrate, but they do not by themselves amount to semantic repo understanding
|
||||
- vendor Codex directly into the parent repo instead of keeping it as a gitlink/submodule so Epiphany harness changes can be reviewed and committed atomically with the surrounding project state
|
||||
- for Phase 2, treat the presence of SessionState.epiphany_state as the internal activation signal and inject a bounded Epiphany summary into the developer-context path during build_initial_context rather than inventing a public operator surface early
|
||||
- Phase 2 is landed: a dedicated EpiphanyStateInstructions fragment now renders bounded Epiphany thread state into the developer prompt path during build_initial_context, with omission/inclusion/resume coverage and a stable snapshot
|
||||
- Phase 3 read-surface slice is landed: app-server protocol Thread payloads now carry optional typed epiphany_state hydrated from live CodexThread state when available and otherwise reconstructed from rollout with rollback/compaction semantics; dedicated Epiphany update RPCs and live notifications remain deferred
|
||||
- Epiphany should be an opinionated software development agent: pre-compaction and pre-handoff persistence of map, evidence, and next action are part of the workflow, not optional operator folklore
|
||||
- compaction handling should be pressure-aware rather than reactive: when context pressure rises, Epiphany should narrow the active move and persist checkpoints before forced compaction actually hits
|
||||
- repo-local AGENTS instructions should carry the session bootstrap and re-entry protocol explicitly, including running epiphany_state.py status on fresh load and after compaction
|
||||
- implement the first Phase 4 retrieval slice as a query-time hybrid retriever: reuse existing codex_file_search substrate for exact/path lookup and use workspace-local BM25 chunk search as the first semantic backend so the retrieval seam is proven before adding persistence
|
||||
- for the first persistent semantic retrieval store after the verified BM25 baseline, prefer a real vector database such as Qdrant over JSON/blob/postgres-thrash designs; treat Qdrant as the preferred persistent semantic backend rather than a hard requirement, keep exact/path lookup as a first-class organ, and keep BM25 available as a bootstrap/fallback/control path when Qdrant is unavailable or not configured instead of turning retrieval into vector-only soup
|
||||
- land the first persistent-semantic follow-up as an explicit indexing/update path rather than a hidden side effect in retrieval: keep `thread/epiphany/retrieve` read-only, add additive `thread/epiphany/index`, persist Qdrant index metadata under `codex_home`, use local Ollama embeddings by default, and fall back to BM25 whenever the persistent backend is stale, missing, or unavailable
|
||||
- extract Epiphany-owned implementation into a sibling repo-owned crate where possible, leaving vendored Codex with thin host adapters plus the typed protocol/thread/app-server seams that make the integration first-class
|
||||
- keep the licensing path compatible with future commercial use: Project-Authored Material outside `vendor/codex/**` is public under PolyForm Noncommercial 1.0.0 plus separate commercial terms, and outside contributions require a CLA granting broad sublicensing/relicensing rights
|
||||
- treat Epiphany as a fork of Codex with an opinionated modeling architecture, not merely a Codex collaboration mode or preset
|
||||
- use natural language and metaphor in algorithmic maps only after source-grounding the relevant mechanism; the metaphor should compress verified control flow, not decorate a guess
|
||||
- treat meticulous workflow discipline as part of the product, not as slowdown: rehydrate before acting, source-ground maps before prose, keep each slice bounded, verify the real seam, then persist map/evidence/handoff before moving on
|
||||
- enforce immediate anti-cruft reverts for regression and benchmark work: if a fix attempt does not fix the regression or move the benchmark, revert it before trying the next hypothesis and record the rejected path when useful
|
||||
- render the anti-Jenga regression/benchmark discipline inside the Epiphany developer-state prompt so hydrated Epiphany turns carry the operational rule at runtime instead of relying on AGENTS prose alone
|
||||
- live app-server smoke verified the explicit Qdrant indexing path against a loaded ephemeral thread rooted at `epiphany-core`; env/default Qdrant/Ollama backend config is good enough for the current slice, so defer a first-class config surface until it hurts for a real reason
|
||||
- land Epiphany's first explicit typed state-update surface as `thread/epiphany/update`: loaded-thread-only, revision-checked when requested, append observations/evidence, replace bounded map/scratch/churn fields, persist an immediate `RolloutItem::EpiphanyState`, and keep retrieval read-only
|
||||
- land Epiphany's first typed distillation/proposal surface as `thread/epiphany/distill`: loaded-thread-only, read-only, deterministic observation/evidence patch generation with a concrete `expectedRevision`, and explicit promotion through `thread/epiphany/update`
|
||||
- land Epiphany's first explicit promotion gate as `thread/epiphany/promote`: loaded-thread-only, verifier-backed, rejects failed candidates without mutation, and applies accepted candidates through the existing durable update path
|
||||
- land the first richer map/churn promotion safety layer: state replacement promotions must include explicit observations and patch evidence, and subgoal/invariant/graph/frontier/checkpoint/churn replacements get structural validation in `epiphany-core` before reaching the durable update path
|
||||
- keep Windows app-server verification explicit about stack pressure: Cargo config sets `RUST_MIN_STACK=67108864` so the test binary does not depend on shell folklore or tiny default test-thread stacks
|
||||
- harden read-only map/churn proposal quality incrementally: `thread/epiphany/propose` should reuse existing architecture graph nodes by exact code-ref, same-path overlap, or deterministic path-node id before creating new candidate nodes, preserve existing node identity/metadata, and describe whether the candidate refines, expands, or updates the map in churn
|
||||
- harden proposal frontier focus incrementally: `thread/epiphany/propose` should follow existing graph links between architecture and dataflow nodes and mark named incident graph edges active so prompt rendering sees relevant connected context
|
||||
- harden proposal selection and churn incrementally: `thread/epiphany/propose` should require selected verified observations to cite accepting `recent_evidence`, summarize the evidence-backed selection in the candidate observation/evidence, and derive `diff_pressure` from the candidate map delta, touched paths, selected observation count, and unresolved write risk instead of merely inheriting old churn
|
||||
- harden proposal graph semantics incrementally: `thread/epiphany/propose` should score selected observations/evidence, use the strongest selected signal for candidate wording, and reuse unanchored architecture graph nodes only through strict unique semantic overlap while refusing ambiguous semantic matches and keeping code-anchored nodes under concrete ref/path/id matching
|
||||
- harden proposal observation selection incrementally: when `observationIds` is omitted, read-only `thread/epiphany/propose` should choose a bounded coherent path cluster from existing verified, evidence-backed observations using source/evidence quality plus graph-frontier focus, without mutating state or bypassing promotion
|
||||
- a full source-grounded audit of the Epiphany algorithmic map confirmed the current typed spine is coherent: protocol state, prompt rendering, rollout persistence, thread hydration, explicit retrieval/indexing, read-only distillation/proposal, verifier-backed promotion, and the single durable update writer all describe the current control flow; the Perfect Machine pressure belongs above proposal/promotion, not in another writer or shiny surface
|
||||
- harden proposal map-delta judgment incrementally: read-only `thread/epiphany/propose` should distinguish exact-ref refinement, same-path broadening, deterministic-node reuse, semantic unanchored-node reuse, and new candidate surfaces before setting graph freshness and `diff_pressure`
|
||||
- harden observation distillation incrementally: read-only `thread/epiphany/distill` should summarize noisy tool/command/shell/model output into salient bounded evidence and default evidence kind to `tool-output` or `model-output` when appropriate
|
||||
- harden source-output distillation salience ranking incrementally: final test result, failure, error, exit-code, passed, and finished lines outrank generic warnings when compressing noisy tool output, while warning-only output still preserves the warning as the central signal
|
||||
- harden promotion policy incrementally: `thread/epiphany/promote` should reject risky churn deltas unless they carry explicit warning rationale and strong verifier evidence kind, treating graph expansion, broadening, semantic anchoring, updates, and medium/high pressure as risky even when a patch tries to understate pressure; strong verifier kinds are token-matched so substring accidents such as `contest` do not satisfy `test`
|
||||
- live-smoke the richer Phase 5 app-server chain with a reusable repo-local harness: source-output distillation produced `tool-output` with final result lines ahead of generic warnings, proposal stayed read-only, risky churn rejected without warning, expansion-with-low-pressure churn rejected without warning, risky churn rejected with weak or substring verifier evidence, and accepted risky churn persisted only with warning plus strong verifier evidence
|
||||
- harden the first live Epiphany state notification seam: experimental `thread/epiphany/stateUpdated` publishes the updated typed state after successful direct `thread/epiphany/update` and accepted `thread/epiphany/promote`, includes a typed `source` of `update` or `promote`, event-level `revision`, and typed `changedFields`, while rejected promotions still do not mutate state or emit update notifications
|
||||
- harden accepted-promotion notification accuracy: because accepted `thread/epiphany/promote` always appends verifier evidence to durable state, promotion notifications must include `evidence` in `changedFields` even when the submitted patch evidence list was empty
|
||||
- harden direct write responses: successful `thread/epiphany/update` and accepted `thread/epiphany/promote` responses now include response-level `revision` and `changedFields`, matching the live notification metadata for initiating callers
|
||||
- harden rejected-promotion notification silence: the richer Phase 5 app-server smoke now asserts rejected `thread/epiphany/promote` calls do not emit `thread/epiphany/stateUpdated`
|
||||
- harden direct update integrity: `thread/epiphany/update` now rejects malformed appended observations/evidence and structurally invalid replacement fields before durable persistence, including empty append record fields, duplicate append ids, durable id reuse, observations that cite missing evidence ids, and graph/frontier/checkpoint/subgoal/churn replacement shape errors; invalid direct updates leave revision unchanged and emit no state update notification
|
||||
- harden write/read surface consistency: successful direct update and accepted promote responses plus `thread/epiphany/stateUpdated` notifications now publish the same client-visible live Epiphany state projection as `thread/read`, including the non-durable retrieval summary backfill when state exists without persisted retrieval metadata
|
||||
- avoid self-reinforcing handoff notes that keep prescribing tiny safety-hardening slices after a phase has become complete enough; bounded slices are a way to land work safely, not a reason to orbit the same seam forever
|
||||
- treat persistent state cruft as the same failure class as code cruft: implementation plans and harness-surface notes should distill current truth, preserve boundaries, and move historical proof back to git/evidence instead of accumulating every landed micro-slice
|
||||
- land the first Phase 6 reflection boundary slice as read-only `thread/epiphany/scene`: a derived client-shaped projection over existing Epiphany state that summarizes objective, active subgoal, invariants, graph focus, retrieval status, observations, evidence, churn, and available control-plane actions without persisting new state or making the GUI/client authoritative
|
||||
- Epiphany is a fork-level modeling architecture, not merely a Codex collaboration mode.
|
||||
- Authoritative Epiphany state lives in Codex protocol/core session and rollout state.
|
||||
- The prompt reads typed state through a bounded `<epiphany_state>` developer fragment.
|
||||
- Clients read typed state through `Thread.epiphanyState` and compact reflections such as `thread/epiphany/scene`.
|
||||
- Durable typed state writes route through `thread/epiphany/update` or accepted `thread/epiphany/promote`.
|
||||
- `thread/epiphany/retrieve`, `thread/epiphany/distill`, `thread/epiphany/propose`, and `thread/epiphany/scene` stay read-only.
|
||||
- `thread/epiphany/index` writes the retrieval catalog, not durable Epiphany understanding.
|
||||
- Qdrant is the preferred persistent semantic backend; BM25 remains the bootstrap/fallback/control path.
|
||||
- `epiphany-core` owns prompt rendering, rollout replay helpers, retrieval/indexing, distillation, proposal, and promotion policy where possible.
|
||||
- Vendored Codex keeps the thin typed host seam: protocol types, thread bridges, app-server protocol, request routing, and rollout integration.
|
||||
- The current algorithmic map is the source-grounded description of live control flow.
|
||||
- Compact-Rehydrate-Reorient-Continue is an architecture primitive; automatic runtime coordination is not landed yet.
|
||||
- GUI/client work must reflect or steer typed state rather than manufacture a second source of truth.
|
||||
- Long-running indexing, remap, verification, and specialist work should eventually surface as typed jobs/progress.
|
||||
- Handoff, plan, harness-surface, and scratch files must have distinct jobs and must not become duplicate brains.
|
||||
- A machine is perfect when every remaining part visibly deserves to exist; this applies to persistent memory too.
|
||||
|
||||
landed_baseline:
|
||||
phases:
|
||||
- Phase 1: durable Epiphany thread state and rollout persistence.
|
||||
- Phase 2: prompt integration through rendered Epiphany state.
|
||||
- Phase 3: typed client read surface through `Thread.epiphanyState`.
|
||||
- Phase 4: hybrid retrieval plus explicit Qdrant indexing with BM25 fallback.
|
||||
- Phase 5: typed update/distill/propose/promote/read/notification control plane.
|
||||
- Phase 6: first read-only scene/reflection surface.
|
||||
guardrails:
|
||||
- Use `tools/epiphany_phase5_smoke.py` before modifying update, distill, propose, promote, read-projection, or notification behavior.
|
||||
- Use focused scene/protocol/schema checks for scene-only changes.
|
||||
- Use `CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex` for Codex Rust work on this Windows machine.
|
||||
- Do not parallelize cargo builds/tests against the same target directory.
|
||||
|
||||
rejected_paths:
|
||||
- name: pinned_map_only
|
||||
reason: still one token stream with no typed write semantics
|
||||
- name: train_new_base_model_first
|
||||
reason: too expensive for a first falsifiable experiment
|
||||
- name: exact_name_open_codex_cli_as_gui_surface
|
||||
reason: ymichael/open-codex is terminal-focused and has no Web UI or desktop surface
|
||||
- name: read_opencodex_web_readme_claude_models_as_current_gui_support
|
||||
reason: the Web UI has stale/aspirational Claude/Gemini model definitions, but the new-session selector only exposes Codex and the serve backend rejects non-Codex agents
|
||||
- name: imdigitalashish_opencodex_as_primary_gui_surface
|
||||
reason: the repo is a Tauri wrapper around an archived/vendored opencode CLI, has mismatched GUI/API model IDs versus the CLI model registry, runs the non-interactive tool path with broad auto-approval, and commits generated/binary/local-state artifacts
|
||||
- name: third_party_opencodex_forks_as_gui_base
|
||||
reason: audited candidates were either terminal-only, stale/aspirational, or incoherent wrappers; the comparison clones were removed from vendor to avoid building on untrusted drift
|
||||
- name: third_party_opencodex_forks_as_primary_gui_base
|
||||
reason: audited candidates were terminal-only, stale/aspirational, or incoherent wrappers
|
||||
- name: monolithic_json_vector_store
|
||||
reason: large embedding stores that rewrite whole files thrash and hide storage pain until it dominates the system
|
||||
- name: append_only_persistent_notes
|
||||
reason: persistent state that accumulates every local truth becomes memory cruft and weakens rehydration
|
||||
|
||||
current_status:
|
||||
summary: Workspace initialized with protocol files, typed state, handoff notes, architecture maps, and a rolling implementation plan against vendored Codex. Phase 1 durable state, Phase 2 prompt integration, the minimal Phase 3 typed read surface, Phase 4 retrieval/indexing/core-extraction, and the Phase 5 update/distill/propose/promote/read/notification control plane are landed on `main` and complete enough. The first Phase 6 reflection-boundary slice is now implemented as read-only `thread/epiphany/scene`, a derived client-shaped scene over existing authoritative Epiphany state. The baseline includes explicit Qdrant indexing with BM25 fallback, typed `thread/epiphany/update`, read-only `thread/epiphany/distill`, read-only `thread/epiphany/propose`, verifier-backed `thread/epiphany/promote`, response-level and notification-level revision/changed-field metadata, client-visible write/read projection consistency with retrieval-summary backfill, direct-update append/replacement validation, source-output-aware distillation, graph-aware proposal selection, risky-delta promotion policy, token-aware verifier-kind matching, reusable richer Phase 5 smoke, and the new Phase 6 scene projection.
|
||||
next_action: Treat `thread/epiphany/scene` as the first Phase 6 reflection baseline. Next, either live-smoke the scene method through app-server or extend the reflection boundary toward a minimal job-state/progress surface; do not restart Phase 5 hardening without a concrete regression.
|
||||
summary: Phase 1 durable state, Phase 2 prompt integration, Phase 3 typed read, Phase 4 retrieval/indexing, Phase 5 update/distill/propose/promote/read/notification, and the first Phase 6 scene surface are landed. Persistent state was just cut down so map, handoff, plan, harness surfaces, scratch, and evidence each carry one job instead of becoming a Jenga tower.
|
||||
next_action: Do not continue implementation from this audit automatically. When work resumes, choose one Phase 6 organ; live-smoke `thread/epiphany/scene` through app-server or design a minimal job/progress reflection surface.
|
||||
|
|
|
|||
173
state/scratch.md
173
state/scratch.md
|
|
@ -1,168 +1,27 @@
|
|||
# Scratch
|
||||
|
||||
This file is intentionally disposable.
|
||||
This file is disposable working memory for the current bounded subgoal.
|
||||
|
||||
## Current Subgoal
|
||||
|
||||
- Continue Phase 5 proposal-quality hardening beyond graph-node reuse, linked frontier focus, evidence-backed selection, selected-observation prioritization, strict unanchored-node semantic reuse, automatic bounded observation selection, and map-delta churn pressure, without hidden writes.
|
||||
Audit and cut persistent state so Epiphany rehydrates into a sharper machine,
|
||||
not a larger one.
|
||||
|
||||
## Working Notes
|
||||
|
||||
- Phase 4 is landed retrieval/indexing/core-extraction. Phase 5 is the current semantic distillation/promotion/proposal phase.
|
||||
- First read-only `thread/epiphany/propose` slice is landed in the working tree:
|
||||
- `epiphany-core/src/proposal.rs` owns deterministic `propose_map_update`
|
||||
- selected observations must already exist in thread state, have accepting status, and carry code refs
|
||||
- selected observations must cite accepting `recent_evidence`; missing or failed backing evidence now rejects proposal before graph/churn drafting
|
||||
- proposal now tries exact code-ref overlap, same-path overlap, and deterministic path-node id fallback against existing architecture graph nodes before creating new candidate path nodes
|
||||
- matching nodes are focused and enriched with newly observed refs without overwriting their existing title, purpose, or status
|
||||
- proposal expands frontier focus through existing graph links, marks named incident architecture/dataflow edges active, emits proposal observation/evidence with evidence-backed selection counts plus reused/created node counts, and marks churn as `proposal_refines_map`, `proposal_expands_map`, or `proposal_updates_map`
|
||||
- proposal now scores selected observations/evidence so candidate wording uses the strongest selected verifier/test/smoke-backed signal instead of raw id order
|
||||
- proposal can reuse an unanchored architecture graph node through strict unique semantic overlap, but refuses tied semantic matches and leaves code-anchored nodes under concrete exact/path/deterministic-id matching
|
||||
- proposal can now omit `observationIds`; in that case `epiphany-core` ranks existing verified, code-ref-bearing observations with accepting evidence, scores them by source/evidence quality plus graph-frontier focus, and selects up to four observations from the strongest coherent path cluster
|
||||
- churn `diff_pressure` now comes from the candidate map delta, touched path count, selected observation count, and existing unexplained write risk, with existing pressure kept as a floor
|
||||
- app-server exposes experimental loaded-thread-only `thread/epiphany/propose`
|
||||
- live stdio smoke proved propose is read-only, and propose -> promote persists graph/churn only after verifier evidence
|
||||
- The Phase 4 retrieval/indexing/core-extraction anchor is `80c29e0` on `main`. The older `360dfea` commit is only the first hybrid retrieval anchor, and later `main` also includes the typed update/distill/promote surfaces, promotion safety layer, and app-server stack-pressure fix.
|
||||
- The extraction boundary is now the important truth:
|
||||
- `epiphany-core/src/retrieval.rs` owns the heavy hybrid retrieval/indexing engine
|
||||
- `epiphany-core/src/prompt.rs` owns the Epiphany prompt-state renderer
|
||||
- `epiphany-core/src/rollout.rs` owns the latest-Epiphany-state replay helper used for Phase 3 stored-thread hydration
|
||||
- `epiphany-core/src/lib.rs` re-exports the stable surface used by vendored Codex
|
||||
- `vendor/codex/codex-rs/core/src/epiphany_retrieval.rs` is now a thin re-export wrapper
|
||||
- `vendor/codex/codex-rs/core/src/epiphany_rollout.rs` is now a thin wrapper that supplies the Codex-specific user-turn-boundary predicate
|
||||
- `vendor/codex/codex-rs/core/src/context/epiphany_state_instructions.rs` is now a thin `ContextualUserFragment` adapter around `epiphany_core::render_epiphany_state(...)`
|
||||
- `vendor/codex/codex-rs/core/Cargo.toml` now depends on the sibling crate by path
|
||||
- What still must live in vendored Codex because that is where the typed host seam exists:
|
||||
- protocol types in `vendor/codex/codex-rs/protocol/src/protocol.rs`
|
||||
- `CodexThread` bridge methods in `vendor/codex/codex-rs/core/src/codex_thread.rs`
|
||||
- the user-turn-boundary rule in `vendor/codex/codex-rs/core/src/context_manager/history.rs`
|
||||
- app-server protocol surfaces in `vendor/codex/codex-rs/app-server-protocol/src/protocol/common.rs` and `vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs`
|
||||
- request routing in `vendor/codex/codex-rs/app-server/src/codex_message_processor.rs`
|
||||
- Why this shape is worth keeping:
|
||||
- it shrinks the Apache-mixed surface
|
||||
- it makes modified Codex alone less useful as a standalone Epiphany rebuild kit
|
||||
- it preserves first-class typed integration instead of hiding the machine behind an opaque plugin blob
|
||||
- Retrieval/indexing behavior is still the bounded machine we wanted:
|
||||
- exact/path-ish lookup via `codex_file_search`
|
||||
- semantic lookup via BM25 chunk search when persistent semantic state is unavailable or stale
|
||||
- explicit `thread/epiphany/index` for Qdrant-backed semantic persistence
|
||||
- read-only `thread/epiphany/retrieve`
|
||||
- manifest metadata under `codex_home`
|
||||
- local Ollama embeddings defaulting to `qwen3-embedding:0.6b`
|
||||
- Corpus preflight for the tracked `vendor/codex/codex-rs` source at `vendor/codex` HEAD `d45ab10`: `3642` tracked files / `31.09 MB`.
|
||||
- Do not use raw working-tree size as the retrieval denominator here; build artifacts and other sludge lie.
|
||||
- Verification is now split cleanly across the repo-owned crate and the vendored host:
|
||||
- `cargo fmt --manifest-path .\\epiphany-core\\Cargo.toml`
|
||||
- `cargo test --manifest-path .\\epiphany-core\\Cargo.toml`
|
||||
- `cargo fmt --all`
|
||||
- `cargo test -p codex-core --lib epiphany`
|
||||
- `cargo test -p codex-app-server-protocol --lib thread_epiphany_`
|
||||
- `cargo test -p codex-app-server --lib map_epiphany_`
|
||||
- `cargo test -p codex-core -p codex-app-server-protocol -p codex-app-server --lib --no-run` with `CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex`
|
||||
- Current repo sanity task:
|
||||
- keep docs from describing the already-landed Qdrant/indexing/core-extraction work as a dirty working-tree follow-up
|
||||
- keep README, map, plan, handoff, and Epiphany algorithmic map in agreement about the current landing zone
|
||||
- keep `notes/epiphany-current-algorithmic-map.md` focused on exact current control flow, not general fork-positioning prose
|
||||
- Local dependency sanity:
|
||||
- Qdrant at `http://127.0.0.1:6333` responds and currently has VoidBot collections
|
||||
- Ollama at `http://127.0.0.1:11434` exposes the default `qwen3-embedding:0.6b` model
|
||||
- Mechanical honesty still matters:
|
||||
- do not widen `thread/epiphany/retrieve` into a durable Epiphany-state write without a clean out-of-band rollout/update semantic
|
||||
- do not let `epiphany-core` sprawl into GUI or watcher machinery just because it now owns the bigger organ
|
||||
- do not add metaphors or natural-language modeling prose to an algorithmic map until the relevant source is in context and the prose is anchored to concrete refs
|
||||
- meticulous workflow discipline is not ceremony for its own sake; the useful loop is rehydrate, bound the slice, read the code being described, make the smallest coherent change, verify the seam that matters, and persist the learned state before charging onward
|
||||
- for regression or benchmark work, failed hypotheses are not souvenirs: if a change does not fix the regression or move the benchmark, revert it immediately before trying the next hypothesis
|
||||
- the anti-Jenga rule is now rendered by `epiphany-core/src/prompt.rs` in the Epiphany developer-state block, which is closer to behavior than more AGENTS repetition
|
||||
- Source-grounded Epiphany map audit on 2026-04-24 reread the cited protocol/session/rollout/prompt/thread/app-server/retrieval code before editing:
|
||||
- sharpened the distinction between full core resume reconstruction and the narrower `epiphany-core` stored-thread replay helper
|
||||
- removed unsupported broad wording around thread hydration surfaces and anchored the actual live/reconstructed paths
|
||||
- made the retrieval branch explicit: exact search always runs, Qdrant is used only with a fresh compatible manifest/collection and working Ollama query embedding, otherwise query-time BM25 supplies semantic chunks
|
||||
- corrected indexing wording so the explicit index path returns ready state on successful writes or an error, not a casual stale state
|
||||
- Live app-server smoke on 2026-04-24:
|
||||
- built `codex-app-server.exe` with `CARGO_TARGET_DIR=C:\Users\Meta\.cargo-target-codex`
|
||||
- used an isolated `CODEX_HOME` under `.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/index` with real Qdrant/Ollama returned ready state: 5 files, 198 chunks, `qdrant-ollama-v1:qwen3-embedding:0.6b`
|
||||
- Qdrant collection `epiphany_workspace_fa24bab116f8d229` was created and the manifest landed under the isolated Codex home
|
||||
- `thread/epiphany/retrieve` returned persistent semantic chunks from `src/prompt.rs`, proving the fresh Qdrant path is used after explicit indexing
|
||||
- env/default backend config is sufficient for this slice; do not add a first-class config surface yet
|
||||
- unrelated app-server startup noise remains: project trust warning, plugin sync 403, and unauthenticated OpenAI websocket warning
|
||||
- Typed state-update implementation on 2026-04-24:
|
||||
- added experimental loaded-thread-only `thread/epiphany/update`
|
||||
- protocol patch accepts optional `expectedRevision`, append-only observations/evidence, and bounded replacements for objective, active subgoal, subgoals, invariants, graphs, graph frontier/checkpoint, scratch, churn, and mode
|
||||
- `CodexThread.epiphany_update_state(...)` rejects empty patches, checks revision when supplied, applies the patch to live `SessionState`, increments revision, sets `last_updated_turn_id` from the current reference turn when available, persists `RolloutItem::EpiphanyState`, and flushes rollout
|
||||
- replay helpers now accept an out-of-band Epiphany snapshot before the first user turn so seed updates survive resume
|
||||
- stable app-server schema fixtures were regenerated; the export test now treats Epiphany DTOs as sparse durable state, not conventional response envelopes
|
||||
- verification passed:
|
||||
- `cargo test --manifest-path .\\epiphany-core\\Cargo.toml rollout`
|
||||
- `cargo test -p codex-core --lib epiphany`
|
||||
- `cargo test -p codex-app-server-protocol --lib thread_epiphany_`
|
||||
- `cargo test -p codex-app-server --lib map_epiphany_`
|
||||
- `cargo test -p codex-app-server-protocol`
|
||||
- live app-server stdio smoke passed after rebuilding `codex-app-server.exe`:
|
||||
- started ephemeral loaded thread `019dbffc-c19a-75e0-bf35-c780bee59a68`
|
||||
- called `thread/epiphany/update` with `expectedRevision: 0`
|
||||
- response revision was `1`
|
||||
- `thread/read` returned `epiphanyState.revision == 1`, objective `Smoke-test explicit Epiphany update persistence`, observation `obs-update-smoke`, and evidence `ev-update-smoke`
|
||||
- smoke result: `.epiphany-smoke/update-smoke-result.json`
|
||||
- wire footgun: app-server envelope fields are camelCase, but nested reused Epiphany core DTO fields such as `source_kind`, `understanding_status`, and `recent_evidence` are snake_case
|
||||
- Typed distillation/proposal implementation on 2026-04-24:
|
||||
- added repo-owned `epiphany-core/src/distillation.rs`
|
||||
- added thin vendored core re-export at `vendor/codex/codex-rs/core/src/epiphany_distillation.rs`
|
||||
- added experimental loaded-thread-only `thread/epiphany/distill`
|
||||
- distill is read-only: it returns `expectedRevision` plus a `ThreadEpiphanyUpdatePatch`, and callers must pass that patch to `thread/epiphany/update` to make it durable
|
||||
- `distill_observation(...)` normalizes required `sourceKind`, `status`, and `text`; rejects empty required fields; builds a bounded summary; fingerprints source/status/subject/text into stable observation/evidence ids; defaults test/smoke/verification sources to evidence kind `verification`; and carries code refs into both records
|
||||
- first smoke exposed that returning `expectedRevision: null` for brand-new threads was too loose, so the handler now defaults absent Epiphany state to revision `0`
|
||||
- verification passed:
|
||||
- `cargo test --manifest-path .\\epiphany-core\\Cargo.toml distill`
|
||||
- `cargo test -p codex-core --lib distill`
|
||||
- `cargo test -p codex-app-server-protocol --lib thread_epiphany_`
|
||||
- `cargo test -p codex-app-server --lib thread_epiphany`
|
||||
- `cargo test -p codex-app-server-protocol`
|
||||
- `cargo build -p codex-app-server --bin codex-app-server`
|
||||
- live app-server stdio smoke passed after rebuilding `codex-app-server.exe`:
|
||||
- started ephemeral loaded thread `019dc028-99ce-7b03-8f89-65b072cc2cca`
|
||||
- called `thread/epiphany/distill` with smoke input and a code ref to `src/distillation.rs`
|
||||
- distill returned `expectedRevision: 0`, observation `obs-c9bfcac23d66`, and evidence `ev-c9bfcac23d66`
|
||||
- passing the patch to `thread/epiphany/update` advanced state to revision `1`
|
||||
- `thread/read` returned the generated observation/evidence ids
|
||||
- smoke result: `.epiphany-smoke/distill-smoke-result.json`
|
||||
- Typed promotion gate implementation on 2026-04-24:
|
||||
- added repo-owned `epiphany-core/src/promotion.rs`
|
||||
- added thin vendored core re-export at `vendor/codex/codex-rs/core/src/epiphany_promotion.rs`
|
||||
- added experimental loaded-thread-only `thread/epiphany/promote`
|
||||
- promotion evaluates a patch plus required verifier evidence; failed policy returns `accepted: false` with reasons and no state mutation
|
||||
- accepted policy appends verifier evidence and applies the patch through `CodexThread.epiphany_update_state(...)`, preserving the durable update path as the only state writer
|
||||
- initial policy requires an actual mutation, nonempty verifier evidence, accepting verifier status (`ok`, `accepted`, `verified`, `pass`, `passed`), valid evidence records, unique ids, and evidence-linked observations
|
||||
- live app-server stdio smoke passed:
|
||||
- started ephemeral loaded thread `019dc087-6d3d-7323-9a2f-2487a591ef7a`
|
||||
- distilled a promotion smoke patch
|
||||
- `thread/epiphany/promote` rejected failed verifier evidence with no `epiphanyState`
|
||||
- accepted verifier evidence promoted through update to revision `1`
|
||||
- `thread/read` returned observation `obs-77248505f492`, distill evidence `ev-77248505f492`, and verifier evidence `ev-promote-smoke-verifier`
|
||||
- smoke result: `.epiphany-smoke/promote-smoke-result.json`
|
||||
- Richer promotion safety layer on 2026-04-24:
|
||||
- `epiphany-core/src/promotion.rs` now receives the actual replacement fields instead of only a `has_state_replacements` boolean
|
||||
- state replacement promotions must include explicit observations and patch evidence before verifier evidence can stamp them into the durable update path
|
||||
- subgoal, invariant, graph, graph link, frontier, checkpoint, and churn replacements get lightweight structural validation
|
||||
- `vendor/codex/codex-rs/app-server/src/codex_message_processor.rs` still keeps the host seam thin: it passes the patch fields into `evaluate_promotion`, then accepted promotions go through `CodexThread.epiphany_update_state(...)`
|
||||
- verification passed:
|
||||
- `cargo test --manifest-path .\\epiphany-core\\Cargo.toml`
|
||||
- `cargo test -p codex-core --lib epiphany`
|
||||
- `cargo test -p codex-app-server --lib epiphany`
|
||||
- attempted full `cargo test -p codex-app-server --lib` compiled but hit a pre-existing-looking stack overflow in `in_process_start_uses_requested_session_source_for_thread_start`; Epiphany-scoped app-server tests passed
|
||||
- Stack-overflow trace/fix on 2026-04-24:
|
||||
- the original `in_process_start_uses_requested_session_source_for_thread_start` failure reproduced without `RUST_MIN_STACK`
|
||||
- breadcrumbs showed `thread/start` completed in the processor and the overflow happened before response routing, pointing at app-server request/future stack pressure rather than Epiphany promotion semantics
|
||||
- `RUST_MIN_STACK=67108864` made exact failures pass; later exact failures in guardian lifecycle and thread-start tracing tests confirmed the app-server test binary had crossed a Windows stack threshold
|
||||
- `vendor/codex/codex-rs/.cargo/config.toml` now sets `RUST_MIN_STACK=67108864` so Cargo-driven tests get the required stack without shell folklore
|
||||
- boxed-future experiments in app-server request dispatch were removed after exact repros and the full app-server suite passed with the Cargo stack config alone
|
||||
- full `cargo test -p codex-app-server --lib` now passes 232/232 with no shell `RUST_MIN_STACK` set and no new boxed request-dispatch futures
|
||||
- `notes/epiphany-fork-implementation-plan.md` has already been distilled into a forward plan.
|
||||
- `notes/epiphany-core-harness-surfaces.md` has already been distilled into a surface contract.
|
||||
- `state/map.yaml` should be canonical current truth, not a landed-slice trophy wall.
|
||||
- `notes/fresh-workspace-handoff.md` should be a re-entry packet, not a full historical reconstruction.
|
||||
- `state/evidence.jsonl` remains the durable history channel.
|
||||
- `notes/epiphany-current-algorithmic-map.md` may stay long because its job is source-grounded control-flow audit, not compact re-entry.
|
||||
|
||||
## Open Questions
|
||||
## Decision
|
||||
|
||||
- How much more can move into `epiphany-core` without sacrificing the typed Codex host seam that makes the integration first-class?
|
||||
- How should Epiphany choose the observation set automatically without turning proposal into automatic graph fanfic?
|
||||
Cut stale Phase 5 scratch after this audit lands.
|
||||
|
||||
Do not promote anything from here into the map unless it survives verification or repeated reuse without contradiction.
|
||||
The next implementation move is still Phase 6: either live-smoke
|
||||
`thread/epiphany/scene` or design a minimal job/progress reflection surface.
|
||||
|
||||
Do not promote anything from this scratch into the map unless it survives
|
||||
verification or repeated reuse without contradiction.
|
||||
|
|
|
|||
Reference in a new issue