Expose typed tool invocation status
This commit is contained in:
parent
c0218dba32
commit
15b079db93
7 changed files with 220 additions and 2 deletions
|
|
@ -48,6 +48,7 @@ use std::time::{Duration, Instant};
|
|||
const DEFAULT_APP_SERVER: &str = r"C:\Users\Meta\.cargo-target-codex\debug\codex-app-server.exe";
|
||||
const DEFAULT_CARGO_TARGET_DIR: &str = r"C:\Users\Meta\.cargo-target-codex";
|
||||
const DEFAULT_THREAD_STATE_STORE: &str = "state/thread-state.msgpack";
|
||||
const DEFAULT_RUNTIME_STORE: &str = "state/runtime-spine.msgpack";
|
||||
const REORIENT_BINDING_ID: &str = "reorient-worker";
|
||||
const IMAGINATION_BINDING_ID: &str = "imagination-synthesis-worker";
|
||||
const MODELING_BINDING_ID: &str = "modeling-checkpoint-worker";
|
||||
|
|
@ -107,6 +108,7 @@ struct Args {
|
|||
thread_id: Option<String>,
|
||||
cwd: PathBuf,
|
||||
thread_state_store: PathBuf,
|
||||
runtime_store: PathBuf,
|
||||
ephemeral: bool,
|
||||
json: bool,
|
||||
result: Option<PathBuf>,
|
||||
|
|
@ -127,6 +129,7 @@ impl Args {
|
|||
thread_id: None,
|
||||
cwd: root.clone(),
|
||||
thread_state_store: PathBuf::from(DEFAULT_THREAD_STATE_STORE),
|
||||
runtime_store: PathBuf::from(DEFAULT_RUNTIME_STORE),
|
||||
ephemeral: true,
|
||||
json: false,
|
||||
result: None,
|
||||
|
|
@ -149,6 +152,9 @@ impl Args {
|
|||
"--thread-state-store" => {
|
||||
parsed.thread_state_store = take_path(&mut args, "--thread-state-store")?
|
||||
}
|
||||
"--runtime-store" => {
|
||||
parsed.runtime_store = take_path(&mut args, "--runtime-store")?
|
||||
}
|
||||
"--ephemeral" => parsed.ephemeral = true,
|
||||
"--no-ephemeral" => parsed.ephemeral = false,
|
||||
"--json" => parsed.json = true,
|
||||
|
|
@ -172,6 +178,7 @@ fn run_status(args: &Args) -> Result<Value> {
|
|||
fn run_native_status(args: &Args) -> Result<Value> {
|
||||
let cwd = absolute_path(&args.cwd)?;
|
||||
let store_path = absolute_path(&args.thread_state_store)?;
|
||||
let runtime_store_path = absolute_path(&args.runtime_store)?;
|
||||
let state_entry = if store_path.exists() {
|
||||
load_thread_state_entry(&store_path)
|
||||
.with_context(|| format!("failed to load {}", store_path.display()))?
|
||||
|
|
@ -325,6 +332,7 @@ fn run_native_status(args: &Args) -> Result<Value> {
|
|||
reorient_finding_accepted: finding_signals.reorient_finding_accepted,
|
||||
});
|
||||
let coordinator_json = coordinator_status_json(&coordinator)?;
|
||||
let tool_invocations = native_tool_invocation_surface(&runtime_store_path)?;
|
||||
|
||||
let root = env::current_dir().context("failed to resolve current directory")?;
|
||||
let native_aux = native_auxiliary_status(&root)?;
|
||||
|
|
@ -359,6 +367,7 @@ fn run_native_status(args: &Args) -> Result<Value> {
|
|||
"recommendation": recommendation,
|
||||
},
|
||||
"coordinator": coordinator_json,
|
||||
"tools": tool_invocations.clone(),
|
||||
},
|
||||
"scene": {
|
||||
"threadId": thread_id,
|
||||
|
|
@ -404,6 +413,7 @@ fn run_native_status(args: &Args) -> Result<Value> {
|
|||
"recommendation": recommendation,
|
||||
},
|
||||
"coordinator": coordinator_json,
|
||||
"tools": tool_invocations,
|
||||
"heartbeat": native_aux.heartbeat,
|
||||
"face": native_aux.face,
|
||||
"voidMemory": native_aux.void_memory,
|
||||
|
|
@ -500,6 +510,8 @@ fn run_codex_status(args: &Args) -> Result<Value> {
|
|||
.get("coordinator")
|
||||
.cloned()
|
||||
.unwrap_or_else(|| json!(null));
|
||||
let runtime_store_path = absolute_path(&args.runtime_store)?;
|
||||
let tool_invocations = native_tool_invocation_surface(&runtime_store_path)?;
|
||||
let root = env::current_dir().context("failed to resolve current directory")?;
|
||||
let native_aux = native_auxiliary_status(&root)?;
|
||||
let status = json!({
|
||||
|
|
@ -516,6 +528,7 @@ fn run_codex_status(args: &Args) -> Result<Value> {
|
|||
"reorientResult": reorient_result,
|
||||
"crrc": crrc,
|
||||
"coordinator": coordinator,
|
||||
"tools": tool_invocations,
|
||||
"heartbeat": native_aux.heartbeat,
|
||||
"face": native_aux.face,
|
||||
"voidMemory": native_aux.void_memory,
|
||||
|
|
@ -585,6 +598,22 @@ fn native_role_result(binding_id: &str) -> Value {
|
|||
})
|
||||
}
|
||||
|
||||
fn native_tool_invocation_surface(runtime_store: &Path) -> Result<Value> {
|
||||
let spine_status = epiphany_core::runtime_spine_status(runtime_store)?;
|
||||
let invocations = epiphany_core::runtime_tool_invocation_statuses(runtime_store)?;
|
||||
Ok(json!({
|
||||
"source": "native",
|
||||
"runtimeStore": runtime_store.display().to_string(),
|
||||
"summary": {
|
||||
"present": spine_status.present,
|
||||
"intentCount": spine_status.tool_invocation_intents,
|
||||
"pendingCount": spine_status.pending_tool_invocations,
|
||||
"receiptCount": spine_status.tool_invocation_receipts,
|
||||
},
|
||||
"invocations": invocations,
|
||||
}))
|
||||
}
|
||||
|
||||
fn coordinator_status_json(status: &epiphany_core::EpiphanyCoordinatorStatus) -> Result<Value> {
|
||||
let mut value = serde_json::to_value(status).context("failed to encode coordinator status")?;
|
||||
let decision = value
|
||||
|
|
@ -1043,6 +1072,35 @@ pub fn render_status(status: &Value) -> String {
|
|||
}
|
||||
}
|
||||
}
|
||||
let tools = &status["tools"];
|
||||
let tool_summary = &tools["summary"];
|
||||
lines.extend([
|
||||
String::new(),
|
||||
"Tools".to_string(),
|
||||
format!(
|
||||
"- intents: {} pending: {} receipts: {}",
|
||||
maybe(&tool_summary["intentCount"], "0"),
|
||||
maybe(&tool_summary["pendingCount"], "0"),
|
||||
maybe(&tool_summary["receiptCount"], "0")
|
||||
),
|
||||
format!("- runtime store: {}", maybe(&tools["runtimeStore"], "none")),
|
||||
]);
|
||||
if let Some(invocations) = tools["invocations"].as_array() {
|
||||
if invocations.is_empty() {
|
||||
lines.push("- latest: none".to_string());
|
||||
} else {
|
||||
for invocation in invocations.iter().rev().take(5) {
|
||||
lines.push(format!(
|
||||
"- {}: {} {}/{} ({})",
|
||||
maybe(&invocation["intentId"], "unknown"),
|
||||
maybe(&invocation["status"], "unknown"),
|
||||
maybe(&invocation["server"], "unknown"),
|
||||
maybe(&invocation["toolName"], "unknown"),
|
||||
maybe(&invocation["adapter"], "unknown")
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
lines.extend([
|
||||
String::new(),
|
||||
"Available Actions".to_string(),
|
||||
|
|
|
|||
|
|
@ -64,6 +64,12 @@ fn main() -> Result<()> {
|
|||
println!("jobs: {} open: {}", status.jobs, status.open_jobs);
|
||||
println!("job results: {}", status.job_results);
|
||||
println!("events: {}", status.events);
|
||||
println!(
|
||||
"tool invocations: {} pending: {} receipts: {}",
|
||||
status.tool_invocation_intents,
|
||||
status.pending_tool_invocations,
|
||||
status.tool_invocation_receipts
|
||||
);
|
||||
if !status.supported_document_types.is_empty() {
|
||||
println!("documents: {}", status.supported_document_types.join(", "));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -353,6 +353,7 @@ pub use runtime_spine::EpiphanyRuntimeSession;
|
|||
pub use runtime_spine::EpiphanyRuntimeSessionStatus;
|
||||
pub use runtime_spine::EpiphanyRuntimeSpineStatus;
|
||||
pub use runtime_spine::EpiphanyRuntimeWorkerLaunchRequest;
|
||||
pub use runtime_spine::EpiphanyToolInvocationStatus;
|
||||
pub use runtime_spine::RUNTIME_EVENT_TYPE;
|
||||
pub use runtime_spine::RUNTIME_IDENTITY_KEY;
|
||||
pub use runtime_spine::RUNTIME_IDENTITY_TYPE;
|
||||
|
|
@ -394,6 +395,7 @@ pub use runtime_spine::runtime_role_worker_result;
|
|||
pub use runtime_spine::runtime_schema_catalog_response;
|
||||
pub use runtime_spine::runtime_spine_cache;
|
||||
pub use runtime_spine::runtime_spine_status;
|
||||
pub use runtime_spine::runtime_tool_invocation_statuses;
|
||||
pub use runtime_spine::runtime_worker_launch_request;
|
||||
pub use runtime_spine::write_runtime_hello_frame;
|
||||
pub use runtime_spine::write_runtime_schema_catalog_json;
|
||||
|
|
|
|||
|
|
@ -89,6 +89,7 @@ use epiphany_tool_adapter::EpiphanyToolInvocationReceipt;
|
|||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
use std::collections::BTreeMap;
|
||||
use std::collections::BTreeSet;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::path::PathBuf;
|
||||
|
|
@ -535,9 +536,28 @@ pub struct EpiphanyRuntimeSpineStatus {
|
|||
pub open_jobs: usize,
|
||||
pub job_results: usize,
|
||||
pub events: usize,
|
||||
pub tool_invocation_intents: usize,
|
||||
pub tool_invocation_receipts: usize,
|
||||
pub pending_tool_invocations: usize,
|
||||
pub supported_document_types: Vec<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct EpiphanyToolInvocationStatus {
|
||||
pub intent_id: String,
|
||||
pub adapter: String,
|
||||
pub server: String,
|
||||
pub tool_name: String,
|
||||
pub caller: String,
|
||||
pub reason: String,
|
||||
pub created_at: String,
|
||||
pub status: String,
|
||||
pub receipt_id: Option<String>,
|
||||
pub completed_at: Option<String>,
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct RuntimeSpineInitOptions {
|
||||
pub runtime_id: String,
|
||||
|
|
@ -1240,6 +1260,9 @@ pub fn runtime_spine_status(store_path: impl AsRef<Path>) -> Result<EpiphanyRunt
|
|||
open_jobs: 0,
|
||||
job_results: 0,
|
||||
events: 0,
|
||||
tool_invocation_intents: 0,
|
||||
tool_invocation_receipts: 0,
|
||||
pending_tool_invocations: 0,
|
||||
supported_document_types: Vec::new(),
|
||||
});
|
||||
}
|
||||
|
|
@ -1252,6 +1275,12 @@ pub fn runtime_spine_status(store_path: impl AsRef<Path>) -> Result<EpiphanyRunt
|
|||
let jobs = cache.get_all::<EpiphanyRuntimeJob>()?;
|
||||
let job_results = cache.get_all::<EpiphanyRuntimeJobResult>()?;
|
||||
let events = cache.get_all::<EpiphanyRuntimeEvent>()?;
|
||||
let tool_intents = cache.get_all::<EpiphanyToolInvocationIntent>()?;
|
||||
let tool_receipts = cache.get_all::<EpiphanyToolInvocationReceipt>()?;
|
||||
let receipt_intent_ids = tool_receipts
|
||||
.iter()
|
||||
.map(|receipt| receipt.intent_id.as_str())
|
||||
.collect::<BTreeSet<_>>();
|
||||
let active_sessions = sessions
|
||||
.iter()
|
||||
.filter(|session| {
|
||||
|
|
@ -1284,12 +1313,65 @@ pub fn runtime_spine_status(store_path: impl AsRef<Path>) -> Result<EpiphanyRunt
|
|||
open_jobs,
|
||||
job_results: job_results.len(),
|
||||
events: events.len(),
|
||||
tool_invocation_intents: tool_intents.len(),
|
||||
tool_invocation_receipts: tool_receipts.len(),
|
||||
pending_tool_invocations: tool_intents
|
||||
.iter()
|
||||
.filter(|intent| !receipt_intent_ids.contains(intent.intent_id.as_str()))
|
||||
.count(),
|
||||
supported_document_types: identity
|
||||
.map(|item| item.supported_document_types)
|
||||
.unwrap_or_default(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn runtime_tool_invocation_statuses(
|
||||
store_path: impl AsRef<Path>,
|
||||
) -> Result<Vec<EpiphanyToolInvocationStatus>> {
|
||||
let store_path = store_path.as_ref();
|
||||
if !store_path.exists() {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let mut cache = runtime_spine_cache(store_path)?;
|
||||
cache
|
||||
.pull_all_backing_stores()
|
||||
.with_context(|| format!("failed to read runtime spine {}", store_path.display()))?;
|
||||
let mut receipts = cache
|
||||
.get_all::<EpiphanyToolInvocationReceipt>()?
|
||||
.into_iter()
|
||||
.map(|receipt| (receipt.intent_id.clone(), receipt))
|
||||
.collect::<BTreeMap<_, _>>();
|
||||
let mut statuses = cache
|
||||
.get_all::<EpiphanyToolInvocationIntent>()?
|
||||
.into_iter()
|
||||
.map(|intent| {
|
||||
let receipt = receipts.remove(&intent.intent_id);
|
||||
EpiphanyToolInvocationStatus {
|
||||
intent_id: intent.intent_id,
|
||||
adapter: intent.adapter,
|
||||
server: intent.server,
|
||||
tool_name: intent.tool_name,
|
||||
caller: intent.caller,
|
||||
reason: intent.reason,
|
||||
created_at: intent.created_at,
|
||||
status: receipt
|
||||
.as_ref()
|
||||
.map(|receipt| receipt.status.clone())
|
||||
.unwrap_or_else(|| "pending".to_string()),
|
||||
receipt_id: receipt.as_ref().map(|receipt| receipt.receipt_id.clone()),
|
||||
completed_at: receipt.as_ref().map(|receipt| receipt.completed_at.clone()),
|
||||
error: receipt.and_then(|receipt| receipt.error),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
statuses.sort_by(|left, right| {
|
||||
left.created_at
|
||||
.cmp(&right.created_at)
|
||||
.then_with(|| left.intent_id.cmp(&right.intent_id))
|
||||
});
|
||||
Ok(statuses)
|
||||
}
|
||||
|
||||
pub fn runtime_hello_frame(store_path: impl AsRef<Path>) -> Result<Vec<u8>> {
|
||||
let mut cache = runtime_spine_cache(store_path.as_ref())?;
|
||||
cache.pull_all_backing_stores()?;
|
||||
|
|
@ -2806,6 +2888,73 @@ mod tests {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runtime_spine_derives_tool_invocation_statuses() -> Result<()> {
|
||||
let temp = tempdir()?;
|
||||
let store = temp.path().join("runtime.msgpack");
|
||||
initialize_runtime_spine(
|
||||
&store,
|
||||
RuntimeSpineInitOptions {
|
||||
runtime_id: "epiphany-test".to_string(),
|
||||
display_name: "Epiphany Test".to_string(),
|
||||
created_at: "2026-05-06T00:00:00Z".to_string(),
|
||||
},
|
||||
)?;
|
||||
let mut cache = runtime_spine_cache(&store)?;
|
||||
cache.put(
|
||||
"intent:done",
|
||||
&EpiphanyToolInvocationIntent::new(
|
||||
"done",
|
||||
"codex-mcp",
|
||||
"smoke-server",
|
||||
"smoke_tool",
|
||||
"{}",
|
||||
"model-request-1",
|
||||
"Test completed tool call.",
|
||||
"2026-05-06T00:01:00Z",
|
||||
),
|
||||
)?;
|
||||
cache.put(
|
||||
"intent:pending",
|
||||
&EpiphanyToolInvocationIntent::new(
|
||||
"pending",
|
||||
"codex-mcp",
|
||||
"smoke-server",
|
||||
"waiting_tool",
|
||||
"{}",
|
||||
"model-request-2",
|
||||
"Test pending tool call.",
|
||||
"2026-05-06T00:02:00Z",
|
||||
),
|
||||
)?;
|
||||
let mut failed_receipt = EpiphanyToolInvocationReceipt::new(
|
||||
"receipt-done",
|
||||
"done",
|
||||
"codex-mcp",
|
||||
"smoke-server",
|
||||
"smoke_tool",
|
||||
"failed",
|
||||
"2026-05-06T00:03:00Z",
|
||||
);
|
||||
failed_receipt.error = Some("smoke server absent".to_string());
|
||||
cache.put("receipt:done", &failed_receipt)?;
|
||||
|
||||
let status = runtime_spine_status(&store)?;
|
||||
assert_eq!(status.tool_invocation_intents, 2);
|
||||
assert_eq!(status.tool_invocation_receipts, 1);
|
||||
assert_eq!(status.pending_tool_invocations, 1);
|
||||
|
||||
let invocations = runtime_tool_invocation_statuses(&store)?;
|
||||
assert_eq!(invocations.len(), 2);
|
||||
assert_eq!(invocations[0].intent_id, "done");
|
||||
assert_eq!(invocations[0].status, "failed");
|
||||
assert_eq!(invocations[0].error.as_deref(), Some("smoke server absent"));
|
||||
assert_eq!(invocations[1].intent_id, "pending");
|
||||
assert_eq!(invocations[1].status, "pending");
|
||||
assert!(invocations[1].receipt_id.is_none());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runtime_spine_opens_and_completes_native_jobs() -> Result<()> {
|
||||
let temp = tempdir()?;
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ remembers doctrine; the branch remembers the blade.
|
|||
- `epiphany-model-runtime` is the current provider-neutral executable boundary. It is built by the `epiphany-openai-runtime` crate for now and accepts `--provider openai-codex`; the old `epiphany-openai-runtime` binary, `--openai-runtime-bin`, and `openai-runtime` executor name survive only as compatibility aliases. Coordinator run mode, local wrapper run mode, and repo birth runner should call `--model-runtime-bin` plus `--model-provider`. The typed request/event/receipt contract is now provider-neutral in `epiphany-model-adapter` as `epiphany.model_request.v0`, `epiphany.model_stream_event.v0`, `epiphany.model_receipt.v0`, and `epiphany.model_adapter_status.v0`; OpenAI/Codex documents are adapter evidence behind that boundary, not scheduler/status/state authority.
|
||||
- Coordinator plan/run passes now emit `epiphany.coordinator_run_receipt.v0` into runtime-spine. `coordinator-summary.json` and `coordinator-steps.jsonl` remain useful operator artifacts, but the durable receipt of what the coordinator decided is typed CultCache/CultNet state.
|
||||
- The first tool/MCP contract surface exists in `epiphany-tool-adapter`: `epiphany.tool_capability.v0`, `epiphany.tool_invocation_intent.v0`, and `epiphany.tool_invocation_receipt.v0`. Runtime-spine advertises these as the Epiphany-facing tool boundary. `epiphany-model-runtime` now materializes complete MCP-shaped model tool calls as typed invocation intents, and `epiphany-tool-codex-mcp-spine` is the quarantined executing adapter: it consumes one typed invocation intent from the mixed runtime-spine CultCache store, calls user-declared Codex MCP through `codex-mcp`, and emits a typed invocation receipt. Raw MCP JSON remains protocol-edge cargo; Codex MCP is transport scaffolding, not Epiphany state, prompt, scheduler, or policy authority.
|
||||
- Native status now exposes that quarantined bridge spine without granting it authority. `runtime_spine_status` counts tool invocation intents, receipts, and pending calls; `runtime_tool_invocation_statuses` derives read-only intent/receipt status rows; `epiphany-runtime-spine status` reports the counts; and `epiphany-mvp-status --runtime-store <path>` renders the latest tool calls under `tools`. This is operator visibility only. The next clean backend slice is the typed tool-result feedback path into model continuation, with Epiphany-owned prompt/result policy and no Codex prompt machinery instructing Epiphany agents.
|
||||
- The active foundation directive is now `notes/codex-starvation-and-cultnet-liberation-plan.md`. The previous Codex app-server control-plane rebuild made Epiphany less rotten inside Codex, but that is not the destination. Epiphany must become a native CultCache/CultMesh/CultNet runtime while remaining an honest modified Codex-derived backend for subscription auth/model use. Codex should remain relatively vanilla and keep doing Codex things, including useful app-server and streaming bridge affordances, but it must not own Epiphany state, processes, prompts, scheduler decisions, or policy. The bridge handles interop; Codex and Epiphany do not get to rummage around in each other's organs.
|
||||
- `notes/epiphany-cultmesh-dreaming-roadmap.md` is the new concrete design for distributed Epiphany dreaming. The invariant is hard: private state stays local; public dreams are separately authored typed documents distributed through CultMesh/CultNet; foreign dreams are thought weather until a reviewed local adoption receipt digests them. The first code slice should be dream schemas plus a local CultMesh-backed store, not public fanout.
|
||||
- CultMesh is now the preferred Rust abstraction for that local store work. The compile-time Rust substrate is repo-contained: `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`. The old `E:\Projects\CultLib\crates\*` dependency body is dead in this checkout and must not be revived by accident. Vendored CultCache reads/writes `cultcache.store.v1`, so `state/ledgers.msgpack` and `epiphany-state status` are aligned again. The first integrations are deliberately small: status, Verse policy, global room policy, organ contract policy, native operator status, native operator snapshots, and local operator run intent/receipt round-trip through CultMesh. Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-status -- smoke --store .\.epiphany-smoke\cultmesh\operator-status.ccmp --runtime-id epiphany-cultmesh-status-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-snapshot -- smoke --store .\.epiphany-smoke\cultmesh\operator-snapshots.ccmp --runtime-id epiphany-operator-snapshot-smoke --snapshot-id smoke-status`, and `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-run -- smoke --store .\.epiphany-smoke\cultmesh\operator-runs.ccmp --runtime-id epiphany-operator-run-smoke --run-id smoke-run` for the focused proofs. Future local dream/status/Verse work should start from CultMesh, not raw CultNet, unless the task is polishing the CultMesh internals themselves. Preserve the three Verse tiers: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Face posts.
|
||||
|
|
@ -182,7 +183,7 @@ remembers doctrine; the branch remembers the blade.
|
|||
- The planning loop is now runtime-backed and operator-visible. Typed captures, backlog items, roadmap streams, Objective Drafts, and GitHub issue source refs live in `EpiphanyThreadState`, validate through revision-gated `thread/epiphany/update`, render into prompts when present, project read-only through the `planning` view lens, render in the GUI Planning panel, can be synthesized by the fixed Imagination/planning lane, and can be explicitly adopted through the artifacted `adoptObjectiveDraft` GUI action. Chat is deliberation, not an objective pipe; ideas and GitHub Issues remain planning state until explicit human adoption.
|
||||
- The bridge/dashboard slice is now landed far enough to test locally. Native `epiphany-rider-bridge` inspects Rider installation, solution, VCS, changed files, and captures file/selection/symbol context into `.epiphany-gui/rider` artifacts; Aquarium has Inspect Rider and renders Rider audit artifacts in Environment; Aquarium also embeds the adjacent EpiphanyGraph viewer over typed `graphs.architecture`, `graphs.dataflow`, and `graphs.links`.
|
||||
- A first Rider plugin scaffold lives under `integrations/rider`: tool window, Refresh status, and Send Context to Epiphany action. It shells through native `epiphany-rider-bridge` and does not own state. `gradle` is not installed on this machine, so the scaffold is not build-verified yet.
|
||||
- Next real move: continue Codex starvation and native Epiphany ownership. Quarantine Rider/Unity bridge work for now; those artifacts remain optional later environment evidence, not MVP blockers. Keep EpiphanyAgent focused on backend contracts, typed state, coordinator policy, heartbeat scheduling, Face guardrails, prompt-authority separation, and the ongoing purification from Python/JSON scaffolding into Rust/CultCache/CultMesh/CultNet organs. Resume repo birth/Aquarium/Rider/Unity work only when the user explicitly shifts priority back outward. GitHub Issues import is deferred until the backlog source is fresh enough to deserve Imagination's attention.
|
||||
- Next real move: continue Codex starvation and native Epiphany ownership by wiring model-tool receipts back into typed model continuation. Quarantine Rider/Unity bridge work for now; those artifacts remain optional later environment evidence, not MVP blockers. Keep EpiphanyAgent focused on backend contracts, typed state, coordinator policy, heartbeat scheduling, Face guardrails, prompt-authority separation, and the ongoing purification from Python/JSON scaffolding into Rust/CultCache/CultMesh/CultNet organs. Resume repo birth/Aquarium/Rider/Unity work only when the user explicitly shifts priority back outward. GitHub Issues import is deferred until the backlog source is fresh enough to deserve Imagination's attention.
|
||||
- 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.
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -72,6 +72,7 @@ active_subgoals:
|
|||
- Use `notes/epiphany-cultmesh-dreaming-roadmap.md` as the design authority for distributed Epiphany dreaming. Public dreams are separately authored typed documents distributed through CultMesh/CultNet; private state remains local and cannot be shared by flipping a visibility flag. Foreign dreams are external thought weather until a reviewed local adoption receipt digests them into memory, planning, doctrine, or governance.
|
||||
- CultMesh is now the preferred ergonomic Rust abstraction over CultCache and CultNet for Epiphany-owned local database surfaces. The Rust substrate is repo-contained under `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`; the old `E:\Projects\CultLib\crates\*` path is dead in this checkout and must not be reintroduced as a compile-time dependency. Future local Verse/dream/status work should start at CultMesh unless it is explicitly polishing CultMesh internals. Preserve the three-Verse boundary: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult project sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Face posts.
|
||||
- The active priority is Codex starvation and CultNet liberation. Use `notes/codex-starvation-and-cultnet-liberation-plan.md` as the directive and `notes/codex-auth-spine-inventory.md` as the source-grounded keeper list for the retained OpenAI subscription auth/model transport bridge. Classify all Epiphany-relevant JSON contamination, define the native CultNet runtime boundary, keep worker launch/result/selfPatch cargo as typed documents, evacuate Epiphany operator/state/process authority from Codex JSON-RPC, wrap MCP's unavoidable JSON protocol edge in typed Epiphany intent/result/receipt documents, and keep cutting until Epiphany can run its own state and processes without `codex_message_processor.rs` except for bridge compatibility.
|
||||
- The next Codex-starvation slice is typed tool-result feedback into model continuation. The quarantined Codex MCP spine may execute typed tool intents and emit typed receipts, but the runtime/status surface must remain read-only until Epiphany owns the continuation policy. Codex transports tool calls; it must not inject prompt doctrine or decide what Epiphany agents do with tool results.
|
||||
- The May 2026 teardown/rebuild migration in `notes/epiphany-ideal-architecture-rebuild-plan.md` is closed unless a concrete regression reopens it. Preserve the new foundation: Epiphany view/coordinator policy lives in `epiphany-core`, runtime-spine owns job/result lifecycle identity through `runtime_links`, duplicate acceptance is receipt-keyed, public findings stay typed/sealed, view expansion requires a core contract, and app-server remains routing/adaptation rather than a second policy throne.
|
||||
- Treat Phase 5 update/distill/propose/promote/read/notification as complete enough unless a concrete regression appears.
|
||||
- Preserve read-only boundaries for retrieve, distill, propose, freshness, context, graphQuery, roleResult, reorientResult, and the canonical view lenses for scene, jobs, roles, planning, pressure, reorient, crrc, and coordinator.
|
||||
|
|
@ -175,6 +176,7 @@ accepted_design:
|
|||
- Limited native CRRC automation is now wired only at turn-complete safe boundaries: it can submit a compact operation when the read-only coordinator recommends `compactRehydrateReorient` or when a successful pre-compaction checkpoint intervention left a pending compact handoff for the completed turn, and it can launch the fixed `reorient-worker` when the coordinator recommends `launchReorientWorker`. It does not auto-launch modeling or verification, auto-accept findings, promote evidence, edit implementation code, or continue after reviewable semantic results; the rite may carry the stretcher, not declare the patient healed.
|
||||
- Pre-compaction checkpoint intervention is now wired at token-count boundaries: when a loaded Epiphany thread crosses the existing `shouldPrepareCompaction` pressure threshold during an active turn, the harness steers the active agent once for that turn with a bounded CRRC directive to bank scratch/checkpoint/map/evidence before compaction/reorientation. A successful steer marks a turn-scoped pending compact handoff consumed at clean turn completion; this is banking the fire before the dark, not semantic acceptance, broad scheduling, or automatic implementation continuation.
|
||||
- Native `epiphany-mvp-status` is the first dogfood operator view: it starts or reads a thread through app-server and renders scene, planning, pressure, reorient, jobs, role result read-backs, reorient result, CRRC recommendation, heartbeat, Face bubbles, and MVP role lanes as text or machine output without becoming a state store. The old Python status module has been cut; native Rust/CultCache/CultNet surfaces are the product path.
|
||||
- Native status now exposes the quarantined tool/MCP spine as operator-visible read-only state. Runtime-spine counts typed tool invocation intents, receipts, and pending calls; `runtime_tool_invocation_statuses` derives intent/receipt status rows; `epiphany-runtime-spine status` prints the counts; and `epiphany-mvp-status --runtime-store <path>` renders a `tools` section without executing calls, accepting results, or letting Codex prompt machinery steer Epiphany agents.
|
||||
- The `roles` view lens is the harness-native role ownership surface: it projects implementation, Imagination/planning, modeling/checkpoint, verification/review, and reorientation lanes from authoritative typed state, bound jobs, pressure/reorient/CRRC, and worker result status without launching, scheduling, accepting, compacting, or mutating state.
|
||||
- `thread/epiphany/roleLaunch` and `thread/epiphany/roleResult` are the first explicit role-scoped specialist templates: Imagination/planning, modeling/checkpoint, and verification/review launch through fixed heartbeat-backed bindings with typed runtime-spine receipts and can be read back as reviewable findings from typed runtime-spine job results, while implementation stays owned by the main coding agent and reorientation stays on the CRRC-specific launch/result path.
|
||||
- `thread/epiphany/roleAccept` is the first review-gated role finding acceptance path: it accepts completed heartbeat-backed findings from typed runtime-spine results, accepts Imagination/planning findings only when they return a valid planning-only `statePatch` with draft Objective Draft review gates, accepts completed modeling/checkpoint findings only with a modeling-safe `statePatch`, builds accepted evidence/observation/receipt bundles through `epiphany-core`, and rejects verification, implementation, reorientation, job binding, objective adoption, or broad authority fields.
|
||||
|
|
@ -550,4 +552,4 @@ current_status:
|
|||
materializes complete MCP-shaped model tool calls as typed tool invocation
|
||||
intents, and the Codex MCP spine can consume those intents from the mixed
|
||||
runtime-spine store and emit typed success/failure receipts.
|
||||
next_action: Continue Codex starvation and CultNet liberation by deciding the next loop owner for tool results: either a bounded coordinator action that executes pending tool intents and feeds reviewed `ToolResult` input back into a follow-up model turn, or a narrower operator-visible pending-tool review surface first.
|
||||
next_action: Continue Codex starvation and CultNet liberation by wiring typed tool invocation receipts back into model continuation through an Epiphany-owned policy path; the pending-tool operator visibility surface is landed, so the next fork is how follow-up model input is owned without Codex prompt machinery steering Epiphany agents.
|
||||
|
|
|
|||
Reference in a new issue