GameCult/Epiphany
Archived
Watch
9
0
Fork
You've already forked Epiphany
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Surface environment readiness in GUI

Browse source
This commit is contained in:
Meta Vens 2026-04-30 15:11:15 +01:00
commit 664f2c2598
9 changed files with 271 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

37
apps/epiphany-gui/public/operator-snapshot.sample.json
View file

@ -144,6 +144,43 @@
}
},
"artifacts": [
{
"name": "runtime/unity-inspect-sample",
"path": "E:\\Projects\\EpiphanyAgent\\.epiphany-gui\\runtime\\unity-inspect-sample",
"files": [
"unity-bridge-inspection.md",
"unity-bridge-summary.json"
],
"summaryPath": "E:\\Projects\\EpiphanyAgent\\.epiphany-gui\\runtime\\unity-inspect-sample\\unity-bridge-summary.json",
"runtimeAudit": {
"resultPath": "E:\\Projects\\EpiphanyAgent\\.epiphany-gui\\runtime\\unity-inspect-sample\\unity-bridge-summary.json",
"status": "missingEditor",
"projectPath": "E:\\Projects\\Aetheria-Economy",
"projectVersion": "6000.1.10f1",
"note": "Project pins Unity 6000.1.10f1, but no exact editor was found.",
"editorBridge": {
"exists": true,
"path": "E:\\Projects\\Aetheria-Economy\\Assets\\Editor\\Epiphany\\EpiphanyEditorBridge.cs",
"relativePath": "Assets/Editor/Epiphany/EpiphanyEditorBridge.cs",
"executeMethod": "GameCult.Epiphany.Unity.EpiphanyEditorBridge.RunProbe"
},
"installedEditors": [
{
"version": "6000.4.2f1",
"editorPath": "C:\\Program Files\\Unity\\Hub\\Editor\\6000.4.2f1\\Editor\\Unity.exe"
}
],
"candidatePaths": [
"C:\\Program Files\\Unity\\Hub\\Editor\\6000.1.10f1\\Editor\\Unity.exe",
"C:\\Program Files (x86)\\Unity\\Hub\\Editor\\6000.1.10f1\\Editor\\Unity.exe"
],
"searchRoots": [
"C:\\Program Files\\Unity\\Hub\\Editor",
"C:\\Program Files (x86)\\Unity\\Hub\\Editor"
]
},
"modifiedMillis": 1777475848000
},
{
"name": "mvp-loop-selfdogfood-vanilla2-20260429",
"path": "E:\\Projects\\EpiphanyAgent\\.epiphany-dogfood\\mvp-loop-selfdogfood-vanilla2-20260429",

3
apps/epiphany-gui/scripts/visual-smoke.mjs
View file

@ -50,6 +50,9 @@ async function smokeViewport(browser, viewport, screenshotPath) {
await page.goto(url, { waitUntil: "networkidle" });
await page.getByRole("heading", { name: "Operator Console" }).waitFor();
await page.getByText("prepareCheckpoint").waitFor();
await page.getByRole("heading", { name: "Environment" }).waitFor();
await page.getByText("Unity Editor").waitFor();
await page.getByText("Rider").waitFor();
await page.getByText("Role Lanes").waitFor();
await page.getByText("Artifact Bundles").waitFor();
await page.getByRole("button", { name: "Prepare Checkpoint" }).waitFor();

90
apps/epiphany-gui/src-tauri/src/lib.rs
View file

@ -51,8 +51,30 @@ struct ImplementationAudit {
struct RuntimeAudit {
result_path: String,
status: String,
project_path: Option<String>,
project_version: Option<String>,
editor_path: Option<String>,
note: Option<String>,
editor_bridge: Option<EditorBridgeAudit>,
installed_editors: Vec<InstalledUnityEditor>,
candidate_paths: Vec<String>,
search_roots: Vec<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct EditorBridgeAudit {
exists: bool,
path: Option<String>,
relative_path: Option<String>,
execute_method: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct InstalledUnityEditor {
version: Option<String>,
editor_path: Option<String>,
}
#[derive(Debug, Serialize)]
@ -448,22 +470,70 @@ fn read_runtime_audit(root: &Path) -> Option<RuntimeAudit> {
let text = fs::read_to_string(&result_path).ok()?;
let value: Value = serde_json::from_str(&text).ok()?;
let status = value.get("status").and_then(Value::as_str)?.to_string();
let project_version = value
.get("projectVersion")
.and_then(Value::as_str)
.map(ToString::to_string);
let editor_path = value
.get("editorPath")
.and_then(Value::as_str)
.map(ToString::to_string);
Some(RuntimeAudit {
result_path: result_path.display().to_string(),
status,
project_version,
editor_path,
project_path: json_optional_string(&value, "projectPath"),
project_version: json_optional_string(&value, "projectVersion"),
editor_path: json_optional_string(&value, "editorPath"),
note: json_optional_string(&value, "note"),
editor_bridge: read_editor_bridge(&value),
installed_editors: read_installed_editors(&value),
candidate_paths: read_string_array(&value, "candidatePaths"),
search_roots: read_string_array(&value, "searchRoots"),
})
}
fn json_optional_string(value: &Value, key: &str) -> Option<String> {
value
.get(key)
.and_then(Value::as_str)
.map(ToString::to_string)
}
fn read_string_array(value: &Value, key: &str) -> Vec<String> {
value
.get(key)
.and_then(Value::as_array)
.map(|items| {
items
.iter()
.filter_map(Value::as_str)
.map(ToString::to_string)
.collect()
})
.unwrap_or_default()
}
fn read_editor_bridge(value: &Value) -> Option<EditorBridgeAudit> {
let bridge = value.get("editorBridge")?;
Some(EditorBridgeAudit {
exists: bridge
.get("exists")
.and_then(Value::as_bool)
.unwrap_or(false),
path: json_optional_string(bridge, "path"),
relative_path: json_optional_string(bridge, "relativePath"),
execute_method: json_optional_string(bridge, "executeMethod"),
})
}
fn read_installed_editors(value: &Value) -> Vec<InstalledUnityEditor> {
value
.get("installedEditors")
.and_then(Value::as_array)
.map(|items| {
items
.iter()
.map(|item| InstalledUnityEditor {
version: json_optional_string(item, "version"),
editor_path: json_optional_string(item, "editorPath"),
})
.collect()
})
.unwrap_or_default()
}
fn existing_path(root: &Path, name: &str) -> Option<String> {
let path = root.join(name);
path.exists().then(|| path.display().to_string())

70
apps/epiphany-gui/src/App.tsx
View file

@ -269,6 +269,11 @@ export function App() {
const canAcceptVerification = text(roleResults?.verification?.status).toLowerCase() === "completed";
const canAcceptReorient = text(reorientResult?.status).toLowerCase() === "completed";
const canContinueImplementation = text(coordinator.action).toLowerCase() === "continueimplementation";
const unityBridge = latestRuntimeAudit?.editorBridge;
const installedEditors = latestRuntimeAudit?.installedEditors ?? [];
const candidatePaths = latestRuntimeAudit?.candidatePaths ?? [];
const searchRoots = latestRuntimeAudit?.searchRoots ?? [];
const unityBridgeReady = latestRuntimeAudit?.status === "ready" && unityBridge?.exists === true;
return (
<main className="shell">
@ -393,6 +398,58 @@ export function App() {
</section>
)}
<section className="sectionBand">
<SectionHeader title="Environment" icon={<Database size={18} />} />
<div className="environmentGrid">
<article className="environmentCard">
<div className="cardTopline">
<h3>Unity Editor</h3>
<Pill tone={unityBridgeReady ? "ok" : statusClass(latestRuntimeAudit?.status)}>
{unityBridgeReady ? "bridge ready" : text(latestRuntimeAudit?.status, "unknown")}
</Pill>
</div>
<dl className="facts environmentFacts">
<div><dt>Project</dt><dd>{text(latestRuntimeAudit?.projectVersion)}</dd></div>
<div><dt>Editor</dt><dd>{text(latestRuntimeAudit?.editorPath, "missing")}</dd></div>
<div><dt>Package</dt><dd>{unityBridge?.exists ? "present" : "missing"}</dd></div>
<div><dt>Method</dt><dd>{text(unityBridge?.executeMethod)}</dd></div>
</dl>
{latestRuntimeAudit?.note && <p className="environmentNote">{latestRuntimeAudit.note}</p>}
<PathList title="Installed" items={installedEditors.map((editor) => `${text(editor.version)} ${text(editor.editorPath)}`)} />
<PathList title="Candidates" items={candidatePaths} />
</article>
<article className="environmentCard">
<div className="cardTopline">
<h3>Rider</h3>
<Pill tone="neutral">pending</Pill>
</div>
<dl className="facts environmentFacts">
<div><dt>Workspace</dt><dd>{text(request.cwd ?? snapshot?.repoRoot)}</dd></div>
<div><dt>Plugin</dt><dd>not wired</dd></div>
<div><dt>Diagnostics</dt><dd>pending</dd></div>
<div><dt>Diff view</dt><dd>pending</dd></div>
</dl>
<p className="environmentNote">Bridge pending.</p>
</article>
<article className="environmentCard">
<div className="cardTopline">
<h3>Artifacts</h3>
<Pill tone={latestRuntimeArtifact ? "ok" : "neutral"}>{latestRuntimeArtifact ? "available" : "none"}</Pill>
</div>
<dl className="facts environmentFacts">
<div><dt>Runtime bundle</dt><dd>{text(latestRuntimeArtifact?.name)}</dd></div>
<div><dt>Files</dt><dd>{text(latestRuntimeArtifact?.files.length)}</dd></div>
<div><dt>Summary</dt><dd>{text(latestRuntimeArtifact?.summaryPath)}</dd></div>
<div><dt>Project path</dt><dd>{text(latestRuntimeAudit?.projectPath)}</dd></div>
</dl>
<PathList title="Search roots" items={searchRoots} />
<code title={latestRuntimeArtifact?.path}>{text(latestRuntimeArtifact?.path)}</code>
</article>
</div>
</section>
<section className="statusGrid" aria-label="Coordinator summary">
<Panel title="Recommendation" icon={<ClipboardCheck size={18} />}>
<div className={`actionBanner ${statusClass(coordinator.action ?? crrc.action)}`}>
@ -558,6 +615,19 @@ function ArtifactOutcome({ artifact }: { artifact: ArtifactBundle }) {
);
}
function PathList({ title, items }: { title: string; items: string[] }) {
if (!items.length) return null;
return (
<div className="pathList">
<strong>{title}</strong>
{items.slice(0, 4).map((item) => (
<code key={item} title={item}>{item}</code>
))}
{items.length > 4 && <span>{items.length - 4} more</span>}
</div>
);
}
function EmptyState({ label }: { label: string }) {
return <p className="emptyState">{label}</p>;
}

57
apps/epiphany-gui/src/styles.css
View file

@ -166,6 +166,10 @@ input {
padding: 12px;
}
.notice span {
min-width: 0;
}
.dangerNotice {
border-color: #d9b1a4;
color: #6b2418;
@ -185,9 +189,12 @@ input {
}
.notice code {
display: inline;
max-width: min(620px, 70vw);
display: inline-block;
max-width: 100%;
overflow: hidden;
text-overflow: ellipsis;
vertical-align: bottom;
white-space: nowrap;
}
.statusGrid {
@ -304,6 +311,48 @@ dd {
gap: 12px;
}
.environmentGrid {
display: grid;
grid-template-columns: minmax(0, 1.25fr) minmax(260px, 0.75fr) minmax(300px, 0.9fr);
gap: 12px;
}
.environmentCard {
min-width: 0;
border: 1px solid #d9ded5;
border-radius: 8px;
padding: 12px;
background: #ffffff;
}
.environmentFacts {
grid-template-columns: repeat(2, minmax(0, 1fr));
}
.environmentNote {
margin-top: 10px;
color: #3e493f;
font-size: 0.88rem;
line-height: 1.42;
}
.pathList {
display: grid;
gap: 5px;
margin-top: 10px;
}
.pathList strong {
color: #667168;
font-size: 0.72rem;
text-transform: uppercase;
}
.pathList span {
color: #667168;
font-size: 0.78rem;
}
.laneCard,
.findingCard,
.jobRow {
@ -418,6 +467,10 @@ code {
.cardGrid {
grid-template-columns: repeat(2, minmax(180px, 1fr));
}
.environmentGrid {
grid-template-columns: 1fr;
}
}
@media (max-width: 640px) {

14
apps/epiphany-gui/src/types.ts
View file

@ -44,8 +44,22 @@ export interface ArtifactBundle {
runtimeAudit?: {
resultPath: string;
status: string;
projectPath?: string;
projectVersion?: string;
editorPath?: string;
note?: string;
editorBridge?: {
exists: boolean;
path?: string;
relativePath?: string;
executeMethod?: string;
};
installedEditors?: Array<{
version?: string;
editorPath?: string;
}>;
candidatePaths?: string[];
searchRoots?: string[];
};
modifiedMillis?: number;
}

14
notes/fresh-workspace-handoff.md
View file

@ -367,9 +367,12 @@ Aetheria branch `codex/epiphany-unity-editor-bridge` now contains the resident
`Assets/Editor/Epiphany/EpiphanyEditorBridge.cs` package, and
`tools/epiphany_unity_bridge.py` can detect that package and plan named
editor-resident probes/tests through
`GameCult.Epiphany.Unity.EpiphanyEditorBridge.RunProbe`. Runtime execution
still correctly blocks until Unity `6000.1.10f1` is installed. The detailed
next-environment plan now lives in
`GameCult.Epiphany.Unity.EpiphanyEditorBridge.RunProbe`. The GUI Environment
panel now shows the latest Unity runtime audit, resident package presence,
execute method, installed/candidate editor paths, search roots, and artifact
bundle details, with Rider explicitly pending until its bridge exists. Runtime
execution still correctly blocks until Unity `6000.1.10f1` is installed. The
detailed next-environment plan now lives in
`notes/epiphany-rider-unity-integration-plan.md`: Rider is the
IDE/source-context organ, Unity is the editor/runtime fact organ, and Epiphany
remains the durable coordinator/Self. The intended product workflow is
@ -378,9 +381,8 @@ diagnostics, and code refs; Epiphany GUI is the agent dashboard for objectives,
specialist lane state, logs/artifacts, persisted state, and graph/control-flow
views; Unity is the pinned runtime environment for tests, probes, scene
configuration, assets, shaders, and play/edit-mode evidence. Build the
remaining slices before the next run: GUI Environment panel,
EpiphanyGraph-backed GUI graph dashboard, Rider context bridge, and Rider plugin
MVP. The Unity package is not optional decoration: scene files, prefabs,
remaining slices before the next run: EpiphanyGraph-backed GUI graph dashboard,
Rider context bridge, and Rider plugin MVP. The Unity package is not optional decoration: scene files, prefabs,
materials, shaders, ScriptableObjects, asset GUIDs, and prefab overrides must be
inspected from inside the Unity Editor through Unity APIs, not inferred from
serialized text unless there is no editor-level path. The adjacent

4
state/evidence.jsonl
View file

@ -39,8 +39,6 @@
{"ts": "2026-04-30T03:18:48+00:00", "type": "implementation", "status": "ok", "note": "Aetheria supervised dogfood exposed a coordinator policy bug: after the modeling/checkpoint worker was interrupted and roleResult became backendUnavailable, coordinator skipped to verification. Fixed map_epiphany_coordinator so backendUnavailable is treated as a relaunchable role status for modeling and verification; focused Rust test and live coordinator plan now keep verification behind modeling."}
{"ts": "2026-04-30T05:45:20+00:00", "type": "verification", "status": "ok", "note": "Aetheria supervised dogfood tested CRRC through the GUI/coordinator lane: modeling and verification findings were accepted, CRRC compact/reorient/reorientAccept reached state revision 16, rollout replay now preserves out-of-band Epiphany snapshots on fresh resume, and the coordinator clears to continueImplementation after accepted resume reorientation despite stale cumulative pressure."}
{"ts": "2026-04-30T05:45:31+00:00", "type": "verification", "status": "blocked", "note": "Aetheria supervised dogfood exposed the implementation-lane MVP blocker: four continueImplementation turns completed without any tracked Aetheria workspace diff. The latest audited run at .epiphany-dogfood/aetheria-supervised/gui-actions/continueImplementation-1777527640605829200-12724 records workspaceChanged=false and command telemetry shows only Get-Content reads, no write verbs."}
{"ts": "2026-04-30T05:45:38+00:00", "type": "implementation", "status": "ok", "note": "The GUI action bridge now writes implementation-result.json for continueImplementation turns, emits implementation-audit.md on future runs, and the Tauri/React operator console parses implementation-result.json into artifact metadata so the latest no-diff or diff outcome is visible without opening terminal artifacts."}
{"ts": "2026-04-30T05:47:56+00:00", "type": "implementation", "status": "ok", "note": "The GUI now treats a newest no-diff implementation artifact as a soft operator gate: Continue Implementation is paused until the operator reviews or runs another lane, preventing immediate repeated no-diff pseudo-progress from the console."}
{"ts": "2026-04-30T05:54:22+00:00", "type": "verification", "status": "ok", "note": "Stateful no-diff implementation handling landed and was exercised on the Aetheria dogfood thread: continueImplementation-1777528376766401900-25000 produced no tracked diff, thread/epiphany/update marked the investigation checkpoint regather_required with audit evidence, advanced Epiphany state to revision 17, and a follow-up coordinator plan returned regatherManually with implementation blocked."}
{"ts": "2026-04-30T08:18:46+00:00", "type": "implementation", "status": "ok", "note": "CRRC pre-compaction steering now creates a turn-scoped pending compact handoff after successful steer_input, and clean turn completion forces the existing compact automation even if the ordinary coordinator would continue; aborted turns clear the handoff. Focused Rust tests, coordinator smoke, and reorient-launch smoke passed."}
{"ts": "2026-04-30T08:31:23+00:00", "type": "implementation", "status": "ok", "note": "CRRC pressure now uses current context usage from last token telemetry instead of cumulative thread token spend, treats cumulative-only telemetry as unknown, and starts pre-compaction preparation at 80% of the active auto-compact/context limit. Focused pressure/coordinator tests plus pressure and coordinator smokes passed."}
@ -51,7 +49,7 @@
{"ts": "2026-04-30T11:36:00+01:00", "type": "verification", "status": "blocked", "note": "Aetheria dogfood exposed the next MVP product blocker: engine assumptions require editor/runtime integration. A worker launched legacy D:\\Unity\\Editor\\Unity.exe (Unity 5.5.0f3) despite Aetheria pinning Unity 6000.1.10f1. The GUI action prompt now refuses PATH/default/legacy Unity when the exact pinned editor is unavailable, but the real next organ is a typed editor/runtime bridge that resolves pinned editors, runs explicit batch/probe commands, and captures artifacts as evidence."}
{"ts": "2026-04-30T11:43:33+00:00", "type": "implementation", "status": "ok", "note": "First Unity editor/runtime bridge landed: tools/epiphany_unity_bridge.py resolves ProjectSettings-pinned Unity editors, refuses wrong or missing versions, owns batch/quit/projectPath execution, writes inspection/command/log artifacts, and is exposed through GUI Inspect Unity plus implementation prompt guidance. Smoke verified wrong-only roots are rejected, exact fake roots plan dry-run commands, and missing editors block runs; real Aetheria inspection shows pin 6000.1.10f1 while only 6000.4.2f1 is installed."}
{"ts": "2026-04-30T12:10:09+00:00", "type": "design", "status": "ok", "note": "Documented the Rider+Unity environment integration plan in notes/epiphany-rider-unity-integration-plan.md. The plan defines Rider as IDE/source-context organ, Unity as editor/runtime fact organ, and Epiphany as durable coordinator/Self, with seams for a Rider tool window/context bridge, pinned Unity bridge operations, Aetheria-side Unity editor probes, GUI Environment panel, typed environment state, specialist behavior, and verification gates."}
{"ts": "2026-04-30T13:05:00+01:00", "type": "design", "status": "ok", "note": "Next-action priority amended: do not run another Aetheria implementation dogfood pass until the Rider and Unity bridges are in place. The next implementation slice is bridge construction first: named Unity operations, Aetheria-side Unity editor probes, GUI Environment panel, Rider context bridge, and Rider plugin MVP, so Epiphany can test hypotheses through IDE/source and editor/runtime evidence instead of repeating bridge-less supervision scars."}
{"ts": "2026-04-30T13:28:00+01:00", "type": "design", "status": "ok", "note": "Documented the three-pronged development workflow: Rider is the human code view for repo state/source tree/diffs/diagnostics, Epiphany GUI is the agent dashboard for objectives, specialist lanes, logs/artifacts, persisted state, and graph/control-flow visualization, and Unity is the pinned runtime environment for tests, probes, scene configuration, assets, shaders, and play/edit-mode evidence. The adjacent EpiphanyGraph React viewer is now called out as the preferred seed for GUI graph diagramming because it consumes typed `graphs.architecture`, `graphs.dataflow`, and `graphs.links` directly."}
{"ts": "2026-04-30T13:48:00+01:00", "type": "design", "status": "ok", "note": "Unity integration priority corrected: the CLI bridge is only the pinned transport; the first real Unity organ must be an Aetheria-side resident Editor package that inspects scenes, prefabs, serialized component fields, prefab overrides, materials, shaders, ScriptableObjects, asset GUIDs, and scene configuration through Unity APIs, then writes typed artifacts. Direct text parsing of `.unity` and `.prefab` files is not enough for meaningful hypothesis testing or safe refactoring; future mutation support must be narrow, previewed when feasible, explicitly reviewed, and artifact-backed."}
{"ts": "2026-04-30T14:01:37+00:00", "type": "implementation", "status": "ok", "note": "Resident Unity editor bridge slice landed: Aetheria branch codex/epiphany-unity-editor-bridge contains Assets/Editor/Epiphany/EpiphanyEditorBridge.cs for editor-resident project, compilation, scene, prefab, serialized-object, reference-search probes; Epiphany Unity bridge now detects that package and plans named probe/test commands with auditable artifact receipts while still blocking runtime execution until the exact Unity 6000.1.10f1 editor is installed."}
{"ts": "2026-04-30T14:08:49+00:00", "type": "implementation", "status": "ok", "note": "GUI Environment panel landed: apps/epiphany-gui now surfaces the latest Unity bridge runtime audit with project-pinned editor status, resident editor package presence, execute method, installed/candidate editor paths, search roots, and artifact bundle details; Rider remains an explicit pending environment lane until its bridge exists. Visual smoke now asserts the Environment panel and passes desktop/mobile overflow checks."}

5
state/map.yaml
View file

@ -65,7 +65,7 @@ active_subgoals:
- Keep the supervisor out of Epiphany worker thought streams: dogfood artifacts should be operator-safe by default, with direct transcripts and raw result payloads sealed.
- Use `tools/epiphany_agent_telemetry.py` and generated `agent-function-telemetry.json` files to inspect behavior shape without opening sealed transcripts.
- Treat repeated no-diff implementation turns as an MVP blocker, not success. A bounded implementation pass must leave a reviewable workspace diff or an explicit reviewable failure artifact before dogfood can be called healthy.
- Build the Rider and Unity bridges before the next Aetheria implementation dogfood run: the Aetheria-side resident Unity editor package and named Unity bridge operation planner are now landed; next build the GUI Environment panel, EpiphanyGraph-backed GUI graph dashboard, Rider context bridge, and Rider plugin MVP.
- Build the Rider and Unity bridges before the next Aetheria implementation dogfood run: the Aetheria-side resident Unity editor package, named Unity bridge operation planner, and GUI Environment panel are now landed; next build the EpiphanyGraph-backed GUI graph dashboard, Rider context bridge, and Rider plugin MVP.
- Treat the target workflow as three integrated surfaces: Rider is the human code/diff view, Epiphany GUI is the agent dashboard and persisted-state graph view, and Unity is the pinned runtime/test/scene environment.
- Use `notes/epiphany-rider-unity-integration-plan.md` as the source-grounded plan for Rider-as-IDE and Unity-as-editor/runtime integration seams.
@ -130,6 +130,7 @@ accepted_design:
- The product architecture is three-pronged: Rider is the code view for human inspection of repo state, source tree, diffs, diagnostics, and code refs; Epiphany GUI is the agent dashboard for objectives, specialist lane state, logs/artifacts, persisted typed state, and graph/control-flow views; Unity is the runtime environment for pinned tests, probes, scene configuration, assets, shaders, and play/edit-mode evidence.
- Unity integration must be editor-resident, not text-archeology-only: scene files, prefabs, materials, shaders, ScriptableObjects, asset GUIDs, prefab overrides, and serialized component fields should be inspected through a Unity Editor package using Unity APIs, with narrow mutation preview/apply commands and artifact receipts.
- The first resident Unity editor package now lives in the Aetheria branch `codex/epiphany-unity-editor-bridge`: `Assets/Editor/Epiphany/EpiphanyEditorBridge.cs` exposes editor-resident inspect, compilation, scene, prefab, serialized-object, and reference-search probes with JSON/Markdown artifacts. Epiphany's Unity bridge detects that package and plans named probe/test commands through `GameCult.Epiphany.Unity.EpiphanyEditorBridge.RunProbe`, while runtime execution remains blocked until the exact project-pinned Unity editor is present.
- The GUI Environment panel now reflects the latest Unity bridge runtime audit, including project-pinned editor status, resident package presence, execute method, installed/candidate editor paths, search roots, and artifact bundle details; Rider is shown as a pending environment lane until its bridge exists.
- The adjacent EpiphanyGraph React viewer is the preferred seed for GUI graph/control-flow diagramming because it consumes `graphs.architecture`, `graphs.dataflow`, and `graphs.links` directly and exposes node/edge/code-ref inspection with machine-readable graph data behind the visual layout.
- If the agent's persistent instructions, memory, workflow, or state shape are making it less coherent, slower to rehydrate, less honest, or more likely to build Jenga, the agent should ask the user to change it.
- Epiphany should make compaction less like death and more like sleep: bank the fire before the dark, so the next waking thing finds coals instead of ash and can meaningfully resume the pattern instead of merely continuing the task.
@ -194,4 +195,4 @@ rejected_paths:
current_status:
summary: Phase 1 durable state through Phase 6 GUI/coordinator/specialist/CRRC MVP surfaces are landed. The Aetheria supervised run found and fixed real harness wounds in coordinator policy, no-diff audits, stale job/result projection, and reorient acceptance. The Unity incident proved the next blocker is environment access, so `notes/epiphany-rider-unity-integration-plan.md` now governs a three-pronged bridge-building pass: Rider code view, Epiphany GUI agent dashboard, and Unity runtime environment, with Unity integration treated as a resident editor package rather than text-only file inspection.
next_action: Continue the three-pronged Rider/Epiphany GUI/Unity workflow before further Aetheria implementation dogfood: the Aetheria resident Unity editor package and named Unity bridge operation planner are landed; next build the GUI Environment panel, EpiphanyGraph-backed GUI graph dashboard, Rider context bridge, then Rider plugin MVP. The next dogfood run should happen only after Epiphany can gather Rider/source context and Unity/editor runtime evidence through auditable bridges. Do not let implementation workers invoke Unity directly or refactor Unity-owned serialized scene/prefab state as raw text when an editor API path exists; use bridge artifacts as evidence of either a pinned-editor run, runtime/editor facts, or a missing-runtime blocker. Do not inspect raw worker transcripts or `rawResult` payloads unless the user explicitly requests forensic debugging.
next_action: Continue the three-pronged Rider/Epiphany GUI/Unity workflow before further Aetheria implementation dogfood: the Aetheria resident Unity editor package, named Unity bridge operation planner, and GUI Environment panel are landed; next build the EpiphanyGraph-backed GUI graph dashboard, Rider context bridge, then Rider plugin MVP. The next dogfood run should happen only after Epiphany can gather Rider/source context and Unity/editor runtime evidence through auditable bridges. Do not let implementation workers invoke Unity directly or refactor Unity-owned serialized scene/prefab state as raw text when an editor API path exists; use bridge artifacts as evidence of either a pinned-editor run, runtime/editor facts, or a missing-runtime blocker. Do not inspect raw worker transcripts or `rawResult` payloads unless the user explicitly requests forensic debugging.