diff --git a/README.md b/README.md index 861848a5..a3e36168 100644 --- a/README.md +++ b/README.md @@ -141,6 +141,9 @@ verification stop living in the same overworked skull. If you want the human-readable map of the project, start here: +- `docs/epiphany_investor_brief.md`: investor-facing one-page value summary +- `docs/epiphany_body_whitepaper.pdf`: shareable Proprioception whitepaper +- `docs/epiphany_body_whitepaper.tex`: source for the Body architecture paper - `notes/epiphany-anatomy.md`: current organ/sub-agent/substrate/protocol split - `notes/epiphany-current-algorithmic-map.md`: source-grounded control flow of the live machine - `notes/epiphany-fork-implementation-plan.md`: distilled forward plan diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 00000000..12f12d7d --- /dev/null +++ b/docs/README.md @@ -0,0 +1,26 @@ +# Epiphany Docs + +This folder packages the human-readable Epiphany material that should survive +outside the working notes. + +## Investor Packet + +- [Epiphany investor brief](./epiphany_investor_brief.md): one-page value + summary for investors, partners, and design-partner conversations. +- [Epiphany Body whitepaper](./epiphany_body_whitepaper.tex): source TeX for + the Proprioception architecture overview. +- [Epiphany Body whitepaper PDF](./epiphany_body_whitepaper.pdf): compiled + whitepaper for sharing. + +## Source Notes + +- [Investor readiness roadmap](../notes/epiphany-investor-readiness-roadmap.md) + names the Bifrost-first proof rail and metrics. +- [Algorithmic map](../notes/epiphany-current-algorithmic-map.md) records the + live control flow. +- [Fork implementation plan](../notes/epiphany-fork-implementation-plan.md) + records the current architecture and cut lines. +- [Project map](../state/map.yaml) is the canonical slow machine map. + +For GameCult-level investor context, pair this packet with the sibling site +dossier at `E:\Projects\gamecult-site\docs\gamecult_integrated_dossier.tex`. diff --git a/docs/epiphany_body_whitepaper.pdf b/docs/epiphany_body_whitepaper.pdf new file mode 100644 index 00000000..bed64e64 Binary files /dev/null and b/docs/epiphany_body_whitepaper.pdf differ diff --git a/docs/epiphany_body_whitepaper.tex b/docs/epiphany_body_whitepaper.tex new file mode 100644 index 00000000..3e5bc82a --- /dev/null +++ b/docs/epiphany_body_whitepaper.tex @@ -0,0 +1,392 @@ +\documentclass[11pt]{article} +\usepackage[margin=1in]{geometry} +\usepackage{longtable} +\usepackage{array} +\usepackage{hyperref} +\usepackage{xcolor} +\usepackage{enumitem} +\usepackage{titlesec} +\usepackage{microtype} + +\DeclareUrlCommand{\code}{\urlstyle{tt}} +\newcommand{\bodyterm}[1]{\textbf{#1}} +\emergencystretch=3em +\sloppy +\setlist[itemize]{leftmargin=1.5em} +\setlist[enumerate]{leftmargin=1.5em} +\titleformat{\section}{\Large\bfseries}{\thesection}{0.8em}{} +\titleformat{\subsection}{\large\bfseries}{\thesubsection}{0.8em}{} + +\title{Epiphany's Body: A Proprioception Whitepaper} +\author{GameCult / EpiphanyAgent} +\date{June 9, 2026} + +\begin{document} +\maketitle + +\begin{abstract} +Epiphany is an opinionated Codex-derived agent substrate built around a hard +requirement: the model must model the thing it changes. This whitepaper maps +Epiphany's \bodyterm{Body}: the repository, Rust crates, vendored bridge +machinery, typed state stores, schema catalog, runtime binaries, protocol +surfaces, operator artifacts, and external interface boundaries through which +Epiphany senses and acts. The map is written from the Proprioception faculty: +not as product copy, not as lore, but as an architecture overview whose owner, +input, output, invariant, and cut lines remain inspectable. +\end{abstract} + +\section{Definition} + +In Epiphany doctrine, the Body is the substrate Epiphany acts through and +senses: repository files, tools, runtime state, prompts, logs, interfaces, +permissions, hosted systems, and editor/runtime bridges. Body is not Mind. Body +is changed and sensed; Mind admits durable state. Proprioception is the faculty +that models the Body: architecture, dataflow, seams, constraints, invariants, +and the difference between the map and the substrate. + +The practical definition in this repository is: + +\begin{itemize} + \item the root checkout at \code{E:\Projects\EpiphanyAgent}; + \item Epiphany Rust crates such as \code{epiphany-core}, \code{epiphany-state-model}, \code{epiphany-codex-bridge}, model/tool adapters, and OpenAI transport crates; + \item vendored substrate in \code{vendor/codex}, \code{vendor/cultcache-rs}, \code{vendor/cultnet-rs}, and \code{vendor/cultmesh-rs}; + \item typed state stores under \code{state/}; + \item schemas under \code{schemas/cultnet/}; + \item local operator scripts and generated witness artifacts; + \item adjacent service/client bodies: Aquarium, Odin/Gjallar, Eve/CultUI, Bifrost, VoidBot, Rider, Unity, Discord, and future GameCult Verse hosts. +\end{itemize} + +\section{Executive Map} + +Epiphany's current Body is a hybrid machine in transition. Its center of gravity +has moved into typed Rust/CultCache organs, but compatibility arteries still +run through vendored Codex. The live target is not a cleaner pile of Codex +routes. The target is an Epiphany-native CultCache/CultMesh/CultNet body with a +relatively vanilla Codex-derived reliquary retained for OpenAI subscription +auth and model transport. + +\begin{longtable}{>{\raggedright\arraybackslash}p{0.23\linewidth}>{\raggedright\arraybackslash}p{0.32\linewidth}>{\raggedright\arraybackslash}p{0.35\linewidth}} +\textbf{Body Region} & \textbf{Current Owner} & \textbf{Invariant} \\ +\hline +Durable thread state & \code{epiphany-state-model}, \code{epiphany-core} & State shape is typed; prompt rendering is a projection, not authority. \\ +Domain policy & \code{epiphany-core} & Verdicts, launch policy, acceptance rules, runtime lifecycle, and mutation law live here, not in bridge DTOs. \\ +Compatibility bridge & \code{epiphany-codex-bridge} & Translate Codex edge shapes; never become a second policy throne. \\ +Vendored Codex & \code{vendor/codex} & Retain host/app-server/auth/model compatibility where useful; do not let Codex own Epiphany prompts, scheduler, or state. \\ +Runtime spine & \code{epiphany-core/src/runtime_spine.rs} and \code{state/runtime-spine.cc} & Runtime identity, jobs, events, receipts, tool/model documents are typed CultCache records. \\ +Organ memory & \code{state/agents.cc}; agent-memory CLI & Resident work organs use lean work-organ state; Persona uses portable Persona state. \\ +Heartbeat physiology & \code{state/agent-heartbeats.cc} via \code{epiphany-heartbeat-store} & Scheduling, cooldown, rumination, routine, cognition lanes, and active-turn freeze are scheduler physiology, not project truth. \\ +Local Verse & CultMesh over \code{state/local-verse.cc} & Local Verse context is compact prompt/operator context; private state does not become public by flipping a flag. \\ +Schema catalog & \code{schemas/cultnet/index.json} & JSON schema publishes contracts; typed Rust documents remain runtime authority. \\ +Operator artifacts & \code{.epiphany-*}, \code{tools/epiphany_local_run.ps1} & Artifacts witness and lower state; they do not become state owners. \\ +\end{longtable} + +\section{Repository Body} + +The checkout has ten primary Epiphany Rust crates: + +\begin{itemize} + \item \code{epiphany-core}: the main domain organ. It owns state-update + validation, launch documents, runtime spine, heartbeat, memory graph, Persona + projection, Substrate Gate, Mind, Eyes, Hands, Soul, Continuity, CultMesh + integration, surface derivation, smokes, and local operator binaries. + \item \code{epiphany-state-model}: the durable \code{EpiphanyThreadState} + type plus \code{render_epiphany_state}. This is the typed Mind surface that + prompt fragments and views read. + \item \code{epiphany-codex-bridge}: the translation layer between typed + Epiphany documents and vendored Codex JSON-RPC/app-server shapes. Its own + crate header states that it is a bridge, not an authority organ. + \item \code{epiphany-model-adapter}: provider-neutral model request, stream + event, receipt, and status documents. + \item \code{epiphany-openai-adapter}: OpenAI-shaped request/event/receipt and + status documents. + \item \code{epiphany-openai-auth-spine}: Codex-derived auth boundary over + \code{codex-login}. It preserves honest Codex-compatible credential and token + behavior rather than impersonating it from scratch. + \item \code{epiphany-openai-codex-spine}: model transport over vendored Codex + client machinery. + \item \code{epiphany-openai-runtime}: executable model runtime, including + \code{epiphany-model-runtime}. + \item \code{epiphany-tool-adapter}: typed tool capability, invocation intent, + and invocation receipt documents. + \item \code{epiphany-tool-codex-mcp-spine}: quarantined Codex MCP adapter. It + consumes typed tool invocation intents and emits typed receipts; raw MCP JSON + remains adapter-edge cargo. +\end{itemize} + +The vendored region contains: + +\begin{itemize} + \item \code{vendor/codex}: the Codex-derived host and compatibility substrate. + It is tracked directly, not as a submodule. + \item \code{vendor/cultcache-rs}, \code{vendor/cultnet-rs}, and + \code{vendor/cultmesh-rs}: repo-contained Rust Cult substrate. +\end{itemize} + +\section{State Body} + +The \code{state/} directory is the local persistent body. The important stores +are: + +Canonical CultCache store files use the \code{.cc} extension. The local state +body has been migrated to that naming directly; serialization details are +implementation, not file authority. + +\begin{longtable}{>{\raggedright\arraybackslash}p{0.30\linewidth}>{\raggedright\arraybackslash}p{0.60\linewidth}} +\textbf{Store} & \textbf{Role} \\ +\hline +\code{state/map.yaml} & Canonical slow project map: objective, constraints, invariants, dataflow, active subgoals, current status, guardrails, and rejected paths. \\ +\code{state/ledgers.cc} & CultCache-shaped evidence and branch ledger. Future behavior-changing lessons go here, not in an endless activity feed. \\ +\code{state/agents.cc} & Organ self-memory and Persona projection source. Resident work organs use \code{work_organ}; public/person-shaped agents use \code{persona}. \\ +\code{state/agent-heartbeats.cc} & Heartbeat initiative, cooldown, pending turns, cognition lanes, routine physiology, and scheduler pressure. \\ +\code{state/runtime-spine.cc} & Runtime identity, sessions, jobs, job results, events, worker launch requests, role/reorient findings, receipts, model/tool documents, and schema catalog surfaces. \\ +\code{state/thread-state.cc} & Native thread-state store. \\ +\code{state/local-verse.cc} & Local CultMesh Verse context for compact operator and prompt-context packets. \\ +\code{state/memory-graph.cc} & Local memory graph store. \\ +\code{state/persona-discord.toml} & Persona Discord boundary configuration. \\ +\code{state/void-memory.toml} & Void memory bridge configuration. \\ +\code{state/scratch.md} and \code{state/scratch-compaction-*.md} & Scratch surfaces. Scratch is a workbench, not canonical memory. \\ +\end{longtable} + +Lock files sit beside several stores. Some local generated state is currently +untracked, including \code{state/local-verse.cc}, +\code{state/memory-graph.cc}, and \code{.epiphany-character-loop/}. + +\section{CultNet Schema Body} + +The schema catalog in \code{schemas/cultnet/index.json} is the public nerve +chart. Current local grouping from the catalog is approximately: + +\begin{itemize} + \item 10 agent-state schemas; + \item 5 heartbeat schemas; + \item 21 intent schemas; + \item 8 model/OpenAI schemas; + \item 3 tool schemas; + \item 6 runtime schemas; + \item 17 surface schemas; + \item 4 receipt/ledger schemas; + \item 7 other schemas. +\end{itemize} + +The catalog includes runtime identity/session/job/event/result documents, model +requests and receipts, tool invocation intents and receipts, Persona and +work-organ state, heartbeat state, operator CultMesh documents, scene/freshness +/context/graph/pressure/reorient/roles/coordinator surfaces, Unity and Rider +bridge surfaces, Void memory, and repo-initialization documents. + +The invariant is simple: schema JSON describes the contract. Load-bearing +runtime state should be typed Rust documents persisted through CultCache or +projected through CultMesh/CultNet. JSON may remain at hostile edges, schema +publication, sealed forensic artifacts, or named quarantine experiments. + +\section{Runtime Spine} + +\code{epiphany-core/src/runtime_spine.rs} is one of the main spinal cords of +the Body. It imports and registers: + +\begin{itemize} + \item runtime identity, session, job, job-result, and event records; + \item worker launch requests and role/reorient worker result documents; + \item model adapter, OpenAI adapter, and tool adapter documents; + \item surface document types for scene, freshness, context, graph query, + pressure, reorient, CRRC, jobs, roles, role result, reorient result, + planning, coordinator, Persona, Void memory, repo initialization, repo birth + runner, Rider bridge, and Unity bridge; + \item organ receipts for Mind, Eyes, Hands, Soul, Continuity, and Substrate + Gate; + \item CultMesh operator status, snapshots, run intents, run receipts, Verse + policy, global room policy, and organ contract documents. +\end{itemize} + +Runtime state is machinery telemetry. It is not project truth. Durable thread +state may link to runtime records through runtime links, but it must not mirror +or duplicate their lifecycle fields as a competing owner. + +\section{Faculties And Protocol Machinery} + +The embodied sub-agents are: + +\begin{itemize} + \item \bodyterm{Self}: coordination, routing, authority boundaries. + \item \bodyterm{Persona}: public and social expression. + \item \bodyterm{Imagination}: futures, plans, objective drafts, projection. + \item \bodyterm{Eyes}: research, source inspection, evidence ingress. + \item \bodyterm{Proprioception}: internal model of Body shape, dataflow, + architecture, checkpoints, and seams. + \item \bodyterm{Hands}: commands, edits, commits, rollbacks, external action. + \item \bodyterm{Soul}: verification, invariants, ethics, falsification. +\end{itemize} + +The machinery surfaces are: + +\begin{itemize} + \item \bodyterm{Body}: substrate. It is sensed and changed; it does not decide. + \item \bodyterm{Mind}: persistent state and state admission. + \item \bodyterm{Continuity}: compaction, recovery, sleep, stale-turn repair, + and reorientation receipts. + \item \bodyterm{Substrate Gate}: scoped repository/substrate access. +\end{itemize} + +Every embodied sub-agent depends on the other embodied sub-agents, but +dependency does not collapse ownership. A Persona turn, for example, should +move through Substrate-Gate-scoped facts, Mind state, social stimulus, organ +dependencies, Imagination as Projector, Persona as natural-language actor, and +Mind as Interpreter. None of those steps grants Persona hidden state authority. + +\section{Bridge And Codex Reliquary} + +\code{epiphany-codex-bridge} states its boundary plainly: it translates Codex +\code{ThreadEpiphany*} DTOs into Epiphany core documents, projects typed +Epiphany surfaces back into legacy Codex responses, and calls narrow host traits +while Codex still owns some thread persistence. It must not own verdicts, +launch policy, reorientation policy, acceptance rules, runtime-spine lifecycle, +or durable invariants. + +The retained Codex body currently matters for: + +\begin{itemize} + \item Codex-compatible auth identity and token refresh through + \code{codex-login}; + \item OpenAI/Codex model transport through vendored client machinery; + \item useful app-server and streaming compatibility affordances while + Epiphany surfaces are still evacuating to native CultNet/CultMesh contracts. +\end{itemize} + +The starvation doctrine is the deletion line: Codex may be a bridge and a +reliquary, but not Epiphany's prompt authority, state owner, scheduler, runtime +truth, operator API owner, or plugin marketplace brain. + +\section{Operator And Interface Body} + +Current operator access is partly native and partly witness-artifact based: + +\begin{itemize} + \item \code{tools/epiphany_local_run.ps1} is the one-command local operator + wrapper. + \item Native binaries such as \code{epiphany-mvp-status}, + \code{epiphany-mvp-coordinator}, \code{epiphany-verse-query}, + \code{epiphany-operator-run}, \code{epiphany-operator-snapshot}, + \code{epiphany-eve-surface}, \code{epiphany-runtime-spine}, + \code{epiphany-heartbeat-store}, and \code{epiphany-agent-memory-store} + inspect or update typed state. + \item Local artifact directories such as \code{.epiphany-run/}, + \code{.epiphany-dogfood/}, \code{.epiphany-smoke/}, + \code{.epiphany-rumination/}, \code{.epiphany-gui/}, and + \code{.epiphany-character-loop/} witness work and lower typed state for + operator inspection. + \item Aquarium is the richer adjacent operator client. It should render and + steer typed state, not become a state owner. + \item Eve/CultUI is the intended GUI/TUI projection mechanism for typed + CultMesh surfaces. + \item Odin/Gjallar/Yggdrasil are the intended GameCult Verse discovery and + hosting organs for daemon affordances and important trusted Verses. +\end{itemize} + +The service contract invariant is that status surfaces, dashboards, shell +wrappers, bridge adapters, app-server compatibility layers, and renderers must +read typed projections or emit typed command intents. They must not directly +mutate Epiphany truth. + +\section{Primary Dataflows} + +\subsection{State Rehydration And Prompt Projection} + +Durable thread state lives as typed \code{EpiphanyThreadState}. On re-entry, +state is reconstructed from rollout/native state, then rendered into bounded +prompt-facing context through \code{render_epiphany_state}. Prompt injection is +read-only. If a model learns something from that prompt, admitting it back into +durable state requires an explicit update, proposal, promotion, role acceptance, +or other reviewed write path. + +\subsection{View And Surface Projection} + +Scene, jobs, freshness, context, graph query, planning, pressure, reorientation, +CRRC, roles, role result, reorient result, coordinator, Persona, bridge, and +environment surfaces are projections. Their job is to make typed state visible +and actionable. A projection does not own its inputs. A dashboard is a window, +not the vault. + +\subsection{Worker Launch And Runtime Results} + +Launch requests are typed documents. Runtime spine opens jobs, links them to +durable bindings, records model/tool activity, and stores results/receipts. +Role and reorientation findings remain reviewable until Mind and relevant gates +accept them. Implementation now routes through Hands-shaped branch-turn +constraints and should yield one branch/commit evidence slice before +Proprioception refresh. + +\subsection{Tool Calls} + +Tool use travels through typed capability, invocation intent, and invocation +receipt documents. The Codex MCP adapter is an external compatibility executor. +MCP's raw JSON belongs at that boundary; Epiphany's internal tool state is the +typed intent/receipt pair. + +\subsection{Local Verse And Daemon Awareness} + +Local Verse context is queried through CultMesh-backed state and can import +Gjallar daemon affordance summaries. The desired daemon path is Odin/Gjallar for +discovery, Eve/CultUI for inspection surfaces, CultMesh/CultNet for state and +commands, and provider-owned receipts for actions. MCP is not the native +GameCult daemon-control path. + +\section{Invariants} + +\begin{enumerate} + \item CultCache documents are the data model. + \item CultNet is the wire for Epiphany-controlled subsystems. + \item CultMesh is the preferred ergonomic local Verse and operator-store + layer over raw CultCache/CultNet. + \item JSON schema may publish the contract; generic JSON must not become + load-bearing internal state when both sides are Epiphany-owned. + \item Codex is retained for honest compatibility, especially OpenAI auth and + model transport. It must not become Epiphany's state/process/prompt owner. + \item Runtime state is machinery telemetry, not project truth. + \item Operator artifacts are witnesses, not owners. + \item Persona is public/person-shaped state; resident work organs use lean + work-organ state. + \item Heartbeat is scheduler physiology, not project truth. + \item Substrate Gate grants access; Eyes inspects evidence; Hands acts; Soul + verifies; Mind admits durable state; Self routes; Proprioception maps Body. +\end{enumerate} + +\section{Current Cut Line} + +The Body is coherent enough to inspect and extend. The next cuts are concrete: + +\begin{itemize} + \item Keep \code{thread/epiphany/*} JSON-RPC as compatibility projection + only. New operator authority belongs in typed CultNet/CultMesh contracts. + \item \code{codex_message_processor.rs} still participates in routing and + response projection; move Epiphany-owned routing out through the bridge and + native runtime surfaces. + \item Some \code{serde_json::Value} and JSON payloads survive at ingress, + model output, schema, sealed artifacts, and quarantine seams. Preserve them + only at those boundaries; typed documents own Epiphany-internal state. + \item Publish Eve/CultUI compositions from provider-owned CultMesh state; + renderers lower the composition graph without becoming state owners. + \item Treat local Verse and memory graph stores as generated runtime state. + They are inspected through tools and receipts, not tracked as repository + canon. + \item The persisted next action after this pass remains the non-ephemeral + Hands branch-turn smoke and Proprioception refresh proof. +\end{itemize} + +\section{Conclusion} + +Epiphany's Body is no longer a prompt style pasted onto Codex. It is a growing +typed substrate: Rust domain organs, CultCache stores, CultMesh local Verse +documents, CultNet schema contracts, runtime-spine receipts, heartbeat +physiology, memory graph state, model/tool adapter documents, and local +operator surfaces. The current cut line is split authority: Codex host routes, +JSON-RPC compatibility, JSON cargo, and operator artifacts must remain +compatibility or witness surfaces rather than organs. + +The cut line is therefore architectural, not cosmetic. Keep Codex as a +narrow auth/model/compatibility reliquary. Move Epiphany-owned state, scheduler +policy, prompt authority, worker lifecycle, operator surfaces, daemon discovery, +and action receipts through typed CultCache, CultMesh, CultNet, and Eve/CultUI. +That is the Body becoming legible enough to be trusted and sharp enough to keep +building. + +\end{document} diff --git a/docs/epiphany_investor_brief.md b/docs/epiphany_investor_brief.md new file mode 100644 index 00000000..f4f4e751 --- /dev/null +++ b/docs/epiphany_investor_brief.md @@ -0,0 +1,166 @@ +# Epiphany Investor Brief + +Status: June 2026 discussion packet +Audience: investors, design partners, and diligence reviewers + +## One Sentence + +Epiphany is a project-native agent control plane that makes AI coding work +inspectable: the agent must show its map, preserve evidence, separate roles, +survive context loss, and route real changes through reviewable authority +instead of pretending the chat transcript is a brain. + +## Why It Matters + +Most coding-agent products sell speed. Epiphany is aimed at the more expensive +failure: agents can keep producing plausible local edits after they have lost +the global architecture. That failure burns review time, creates adapter piles, +and leaves teams unable to tell whether the next tool swing still belongs to +the machine being built. + +Epiphany turns that hidden state into shared objects: + +- objective and active work +- architecture and dataflow maps +- scratch versus durable memory +- source-grounded evidence +- role lanes for implementation, modeling, research, verification, planning, + Persona, and reorientation +- runtime receipts, tool receipts, and model receipts +- review gates before findings become project truth +- compact operator surfaces for humans and future clients + +The product thesis is not "the model writes more code." The thesis is +coherence-preserving agent labor: a system where humans can inspect what the +agent believes, why it believes it, who authorized action, what evidence exists, +and what should happen next. + +## What Exists Now + +Epiphany is already more than a pitch deck. The current repo contains: + +- typed Rust state and policy in `epiphany-core` and `epiphany-state-model` +- a Codex compatibility bridge rather than a Codex-owned product brain +- CultCache `.cc` stores for runtime, heartbeat, agent, local Verse, memory + graph, and thread state +- provider-neutral model request/event/receipt documents +- typed tool capability, invocation intent, and invocation receipt documents +- runtime-spine job and worker-result documents +- Mind, Substrate Gate, Eyes, Hands, Soul, Continuity, Persona, and heartbeat + contract surfaces +- local operator commands for status, coordinator runs, smoke checks, and + CultMesh/Verse context +- a Proprioception whitepaper that maps the body, owners, inputs, outputs, + invariants, bridges, and current cut line + +The key architectural move is extraction: Epiphany began as a Codex-derived +harness, but the product architecture is moving into typed Rust, CultCache, +CultMesh, and CultNet documents. Codex is being narrowed to the honest +compatibility spine for subscription auth, model transport, and useful host +affordances. + +## Where Bifrost Fits + +The GameCult investment dossier raises the proof bar. Epiphany should not be +sold as a local demo. The investor-ready loop is Bifrost-first: + +```text +Bifrost topic or work item +-> scoped Epiphany execution request +-> bounded role work +-> artifacts and receipts +-> maintainer review +-> accepted or rejected outcome +-> cost, review load, credit, and public-safe proof +``` + +Bifrost owns public work records, dispatch packets, receipts, credit, reward +pressure, and governance. Epiphany owns bounded execution, typed memory, +coordination, verification pressure, and operator-safe proof artifacts. Discord, +VoidBot, repo Personas, and scripts may mirror or initiate pressure, but they +must not become shadow governance. + +## Recent Public Narrative + +Recent GameCult public material gives investors a clean translation layer: + +- `The Free Mouth And The Native Body` frames VoidBot as the free live mouth + and Epiphany as the native high-leverage body. +- `Epiphany In The Interview Chair` gives the job-interview pitch: Epiphany + makes an AI coding agent show its map, prove its cuts, survive context loss, + and stop when it no longer understands the machine. +- The June 2026 GameCult site project pages frame Epiphany as active harness + work, EpiphanyAquarium as the operator interface, Bifrost as public work and + receipts, and Heimdall as identity/grants. +- The daily damage report turns repo motion into a public work log, which is + useful raw material for future Bifrost receipts. + +The investor wrapper should lead with ordinary words: agent work, receipts, +review, cost accounting, identity, governance, and accepted artifacts. The +mythic language is internal doctrine and studio voice; the investable object is +measured human/agent production. + +## Value Proposition + +For developer teams: + +- less review time wasted on incoherent agent output +- persistent project memory across long tasks and context loss +- visible role separation between modeling, implementation, research, and + verification +- safer authority boundaries for tools, file edits, and commits +- artifact and receipt trails suitable for audits and postmortems + +For GameCult: + +- a native agent substrate that can absorb the live lessons from VoidBot +- public/project Personas without hidden state authority +- Bifrost-routed proof work with receipts and credit +- a commercially licensable control plane while preserving free/reference + layers where appropriate + +For investors: + +- a differentiated wedge in AI-native work governance, not just code + generation +- measurable diligence targets: accepted useful work per human review hour, + cost per accepted artifact, fresh-repo success rate, and sealed public-proof + export quality +- optional commercial paths through enterprise Epiphany/Bifrost services, + source-available licensing, support contracts, or mission-aligned affiliates + +## Proof To Ask For + +The next diligence pass should ask for live evidence, not vibes: + +1. Fresh-repo Epiphany demo with scoped objective, typed state, role routing, + artifact output, review, and receipt. +2. Bifrost demo showing topic/work item, dispatch packet, agent transport, + receipt, ledger or credit record, and outcome. +3. Cost accounting: model spend, role time, human review load, accepted + artifact count, rejected-output reasons, and lessons added to memory. +4. Public/private export proof: no raw worker thoughts, transcripts, private + notes, secrets, or operator context in public artifacts. +5. Security model for identity, secrets, write permissions, revocation, + external repo access, and public publishing. +6. Design-partner proof on at least one external or semi-external repo without + supervisor contamination. + +## Packet Contents + +- `docs/epiphany_body_whitepaper.pdf`: shareable architecture whitepaper. +- `docs/epiphany_body_whitepaper.tex`: source for the whitepaper. +- `notes/epiphany-investor-readiness-roadmap.md`: internal readiness roadmap. +- `E:\Projects\gamecult-site\docs\gamecult_integrated_dossier.tex`: broader + GameCult / Epiphany / Bifrost investment dossier. +- `E:\Projects\gamecult-site\GameCult\Blog\the-free-mouth-and-the-native-body.md` + and + `E:\Projects\gamecult-site\GameCult\Blog\epiphany-in-the-interview-chair.md`: + public narrative source material. + +## Bottom Line + +Epiphany is valuable if it can repeatedly turn ambiguous project work into +bounded agent labor with inspectable state, receipts, review, cost accounting, +and accepted artifacts. The whitepaper proves the body is becoming legible. +The investor proof is the Bifrost-first loop producing useful external work.