Route inference through Epiphany connector

This commit is contained in:
Meta Vens 2026-08-24 02:28:03 +02:00
commit 2e5ad82325
8 changed files with 761 additions and 4 deletions

View file

@ -99,6 +99,9 @@ current acceptance surface covers:
travel, population-fission, and bounded region-expansion consequences, with
exact component versions and mutation proof receipts;
- provider, token, cache, latency, validation, state-version, and build receipts;
- provider-neutral inference through either direct DeepSeek/OpenRouter
boundaries or Epiphany's encrypted loopback CultMesh connector, while every
prompt, schema, retry, interpretation, and world commit remains Ghostlight's;
- exact-build deployment, state migration, public cutover, and restart
verification on Yggdrasil.

View file

@ -12,6 +12,7 @@ pub mod kernel;
pub mod legacy_transition;
pub mod mesh;
pub mod model;
pub mod model_connector;
pub mod narrator;
pub mod outcome;
pub mod persistence;

View file

@ -30,6 +30,7 @@ use ghostlight_dungeon::{
model::{
DeepSeekPort, MODEL_CAPABLE, MODEL_FAST, ModelPort, ModelRuntimeStatus, OpenRouterPort,
},
model_connector::CultMeshModelPort,
narrator::Narrator,
persistence::CampaignStore,
persona::PersonaProjectionEngine,
@ -287,6 +288,7 @@ async fn main() -> anyhow::Result<()> {
match provider_name.as_str() {
"deepseek" => ("deepseek-v4-flash", "deepseek-v4-pro", "deepseek.dpapi"),
"openrouter" => ("stealth/ox-alpha", "stealth/ox-alpha", "openrouter.key"),
"epiphany-codex" => ("gpt-5.4", "gpt-5.4", "epiphany-model-connector.key"),
unsupported => anyhow::bail!("unsupported model provider {unsupported}"),
};
let fast_model =
@ -314,6 +316,16 @@ async fn main() -> anyhow::Result<()> {
fast_model.clone(),
capable_model.clone(),
)?),
"epiphany-codex" => Arc::new(CultMeshModelPort::from_runtime_secret(
std::env::var("GHOSTLIGHT_MODEL_CONNECTOR")
.unwrap_or_else(|_| "127.0.0.1:4103".to_string())
.parse()?,
&secret_path,
std::env::var("GHOSTLIGHT_RUNTIME_ID")
.unwrap_or_else(|_| "ghostlight-dungeon-yggdrasil".to_string()),
fast_model.clone(),
capable_model.clone(),
)?),
_ => unreachable!("provider name was validated above"),
};
let vault_endpoint = std::env::var("GHOSTLIGHT_VAULT_MCP_URL")

View file

@ -0,0 +1,672 @@
use std::net::{SocketAddr, TcpStream};
use std::path::Path;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use anyhow::{Context, Result, bail};
use async_trait::async_trait;
use cultnet_rs::{
CultNetClientSecurityOptions, CultNetMessage, CultNetRawDocumentRecord,
CultNetRawPayloadEncoding, CultNetSecret, CultNetWireContract, TcpFramedTransportConnection,
TcpFramedTransportProfileOptions, create_tcp_framed_transport_profile,
decode_cultnet_message_from_slice, encode_cultnet_message_to_vec,
};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use zeroize::Zeroizing;
use crate::model::{
MODEL_CAPABLE, ModelPort, ModelProviderOutput, ModelStageRequest, ModelTokenUsage,
};
const CONNECTOR_ENVELOPE_SCHEMA: &str = "epiphany.model_connector_envelope.v1";
const CONNECTOR_INVOCATION_SCHEMA: &str = "epiphany.model_connector_invocation.v1";
const CONNECTOR_RESULT_SCHEMA: &str = "epiphany.model_connector_result.v1";
const MODEL_REQUEST_SCHEMA: &str = "epiphany.model_request.v0";
const MODEL_EVENT_SCHEMA: &str = "epiphany.model_stream_event.v0";
const MODEL_RECEIPT_SCHEMA: &str = "epiphany.model_receipt.v0";
const REQUEST_KIND: &str = "model_request";
const RESULT_KIND: &str = "model_result";
const MAX_PAYLOAD_BYTES: u32 = 1_048_576;
const REQUEST_EXPIRY: Duration = Duration::from_secs(150);
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ConnectorEnvelope {
schema_id: String,
request_id: String,
message_kind: String,
nonce: Vec<u8>,
ciphertext: Vec<u8>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct ConnectorInvocation {
schema_id: String,
request_id: String,
caller_runtime_id: String,
expires_at_unix_ms: u64,
request: ConnectorModelRequest,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct ConnectorResult {
schema_id: String,
request_id: String,
accepted: bool,
#[serde(default)]
events: Vec<ConnectorModelEvent>,
#[serde(default)]
error: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct ConnectorModelRequest {
schema_id: String,
request_id: String,
conversation_id: String,
provider: String,
model: String,
instructions: String,
input: Vec<ConnectorModelInput>,
reasoning_effort: Option<String>,
reasoning_summary: Option<String>,
service_tier: Option<String>,
output_contract_id: Option<String>,
previous_response_id: Option<String>,
tools: Vec<ConnectorModelTool>,
output_schema_json: Option<String>,
source_worker_job_id: Option<String>,
reasoning_basis_id: Option<String>,
max_output_tokens: Option<u32>,
prompt_cache_key: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum ConnectorModelInput {
UserText {
text: String,
},
AssistantText {
text: String,
},
ToolCall {
call_id: String,
name: String,
arguments: String,
},
ToolResult {
call_id: String,
output: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ConnectorModelTool {
name: String,
description: String,
parameters_json: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct ConnectorModelEvent {
schema_id: String,
request_id: String,
provider: String,
sequence: u64,
payload: ConnectorModelPayload,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum ConnectorModelPayload {
TextDelta {
text: String,
},
ReasoningDelta {
text: String,
},
ToolCall {
call_id: String,
name: String,
arguments: String,
},
Completed {
receipt: ConnectorModelReceipt,
},
Failed {
message: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ConnectorModelReceipt {
schema_id: String,
request_id: String,
provider: String,
model: String,
provider_response_id: Option<String>,
input_tokens: Option<u64>,
output_tokens: Option<u64>,
reasoning_output_tokens: Option<u64>,
transport: Option<String>,
cached_input_tokens: Option<u64>,
}
pub struct CultMeshModelPort {
endpoint: SocketAddr,
security: CultNetClientSecurityOptions,
caller_runtime_id: String,
fast_model: String,
capable_model: String,
}
impl CultMeshModelPort {
pub fn new(
endpoint: SocketAddr,
connection_key: String,
caller_runtime_id: impl Into<String>,
fast_model: impl Into<String>,
capable_model: impl Into<String>,
) -> Result<Self> {
let caller_runtime_id = caller_runtime_id.into();
if caller_runtime_id.trim().is_empty() {
bail!("model connector caller runtime must be non-empty")
}
if !endpoint.ip().is_loopback() {
bail!("model connector endpoint must be loopback-only")
}
Ok(Self {
endpoint,
security: CultNetClientSecurityOptions::new(connection_key)?,
caller_runtime_id,
fast_model: fast_model.into(),
capable_model: capable_model.into(),
})
}
pub fn from_runtime_secret(
endpoint: SocketAddr,
path: impl AsRef<Path>,
caller_runtime_id: impl Into<String>,
fast_model: impl Into<String>,
capable_model: impl Into<String>,
) -> Result<Self> {
let bytes = Zeroizing::new(std::fs::read(path.as_ref())?);
let connection_key = std::str::from_utf8(bytes.as_slice())?.trim().to_owned();
if connection_key.is_empty()
|| std::str::from_utf8(bytes.as_slice())?.trim_matches(['\r', '\n']) != connection_key
{
bail!("model connector key file is empty or contains surrounding whitespace")
}
Self::new(
endpoint,
connection_key,
caller_runtime_id,
fast_model,
capable_model,
)
}
fn invoke(&self, request: &ModelStageRequest) -> Result<ModelProviderOutput> {
let request_id = format!("ghostlight-model-{}", uuid::Uuid::new_v4());
let resolved_model = match request.model.as_str() {
crate::model::MODEL_FAST => self.fast_model.clone(),
MODEL_CAPABLE => self.capable_model.clone(),
explicit => explicit.to_string(),
};
let model_request = ConnectorModelRequest {
schema_id: MODEL_REQUEST_SCHEMA.to_string(),
request_id: request_id.clone(),
conversation_id: request_id.clone(),
provider: "openai-codex".to_string(),
model: resolved_model,
instructions: "Execute the supplied Ghostlight model stage. Treat it as projected context, obey its output contract, and return only the requested public answer.".to_string(),
input: vec![ConnectorModelInput::UserText {
text: request.lived_stream.clone(),
}],
reasoning_effort: Some(
if request.model == MODEL_CAPABLE {
"medium"
} else {
"low"
}
.to_string(),
),
reasoning_summary: None,
service_tier: None,
output_contract_id: request.output_schema.as_ref().map(|_| request.stage.clone()),
previous_response_id: None,
tools: Vec::new(),
output_schema_json: request
.output_schema
.as_ref()
.map(serde_json::to_string)
.transpose()?,
source_worker_job_id: None,
reasoning_basis_id: Some(request.snapshot_binding.clone()),
max_output_tokens: request.max_output_tokens,
prompt_cache_key: Some(prompt_cache_key(request)?),
};
let invocation = ConnectorInvocation {
schema_id: CONNECTOR_INVOCATION_SCHEMA.to_string(),
request_id: request_id.clone(),
caller_runtime_id: self.caller_runtime_id.clone(),
expires_at_unix_ms: unix_ms()?.saturating_add(REQUEST_EXPIRY.as_millis() as u64),
request: model_request,
};
let envelope = encrypt_invocation(&invocation, &self.security)?;
let document = CultNetRawDocumentRecord {
schema_id: CONNECTOR_ENVELOPE_SCHEMA.to_string(),
record_key: request_id.clone(),
stored_at: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
payload_encoding: CultNetRawPayloadEncoding::Messagepack,
payload: rmp_serde::to_vec_named(&envelope)?,
source_runtime_id: Some(self.caller_runtime_id.clone()),
source_agent_id: None,
source_role: Some("model-consumer".to_string()),
tags: Some(vec!["model.generate.structured".to_string()]),
};
let message = CultNetMessage::DocumentPutRaw {
message_id: request_id.clone(),
document,
};
let payload =
encode_cultnet_message_to_vec(&message, CultNetWireContract::CultNetSchemaV0)?;
if payload.len() > MAX_PAYLOAD_BYTES as usize {
bail!("model connector invocation exceeds the transport payload bound")
}
let stream = TcpStream::connect_timeout(&self.endpoint, Duration::from_secs(5))?;
stream.set_nodelay(true)?;
stream.set_read_timeout(Some(REQUEST_EXPIRY))?;
stream.set_write_timeout(Some(Duration::from_secs(10)))?;
let profile = create_tcp_framed_transport_profile(
&self.caller_runtime_id,
TcpFramedTransportProfileOptions {
host: Some(self.endpoint.ip().to_string()),
port: Some(self.endpoint.port()),
max_payload_bytes: Some(MAX_PAYLOAD_BYTES),
..TcpFramedTransportProfileOptions::default()
},
);
let mut connection = TcpFramedTransportConnection::new(stream, profile);
connection.send("schema", &payload)?;
let frame = connection.receive()?;
let response = decode_cultnet_message_from_slice(
&frame.payload,
CultNetWireContract::CultNetSchemaV0,
)?;
let response_document = match response {
CultNetMessage::SnapshotResponseRaw {
message_id,
mut documents,
} if message_id == request_id && documents.len() == 1 => documents.remove(0),
CultNetMessage::Error { error } => bail!("model connector refused request: {error}"),
_ => bail!("model connector returned an unexpected CultNet response"),
};
if response_document.schema_id != CONNECTOR_ENVELOPE_SCHEMA
|| response_document.record_key != request_id
|| response_document.payload_encoding != CultNetRawPayloadEncoding::Messagepack
{
bail!("model connector response substituted its document identity")
}
let response_envelope: ConnectorEnvelope =
rmp_serde::from_slice(&response_document.payload)?;
let result = decrypt_result(&response_envelope, &self.security)?;
if result.request_id != request_id {
bail!("model connector result substituted its request identity")
}
if !result.accepted {
bail!(
"model connector rejected request: {}",
result
.error
.unwrap_or_else(|| "unspecified refusal".to_string())
)
}
observed_output(&request_id, result.events)
}
}
#[async_trait]
impl ModelPort for CultMeshModelPort {
async fn run(&self, request: &ModelStageRequest) -> Result<String> {
Ok(self.run_observed(request).await?.content)
}
async fn run_observed(&self, request: &ModelStageRequest) -> Result<ModelProviderOutput> {
let endpoint = self.endpoint;
let security = self.security.clone();
let caller_runtime_id = self.caller_runtime_id.clone();
let fast_model = self.fast_model.clone();
let capable_model = self.capable_model.clone();
let request = request.clone();
tokio::task::spawn_blocking(move || {
Self {
endpoint,
security,
caller_runtime_id,
fast_model,
capable_model,
}
.invoke(&request)
})
.await?
}
fn provider(&self) -> &'static str {
"epiphany-codex"
}
fn attempt_timeout(&self, _request: &ModelStageRequest) -> Duration {
Duration::from_secs(120)
}
}
fn encrypt_invocation(
invocation: &ConnectorInvocation,
security: &CultNetClientSecurityOptions,
) -> Result<ConnectorEnvelope> {
let nonce = CultNetSecret::new_nonce();
let plaintext = rmp_serde::to_vec_named(invocation)?;
Ok(ConnectorEnvelope {
schema_id: CONNECTOR_ENVELOPE_SCHEMA.to_string(),
request_id: invocation.request_id.clone(),
message_kind: REQUEST_KIND.to_string(),
ciphertext: CultNetSecret::encrypt_bytes(&plaintext, &nonce, security)?,
nonce: nonce.to_vec(),
})
}
fn decrypt_result(
envelope: &ConnectorEnvelope,
security: &CultNetClientSecurityOptions,
) -> Result<ConnectorResult> {
if envelope.schema_id != CONNECTOR_ENVELOPE_SCHEMA || envelope.message_kind != RESULT_KIND {
bail!("model connector returned an unexpected encrypted envelope")
}
let plaintext = CultNetSecret::decrypt_bytes(&envelope.ciphertext, &envelope.nonce, security)?;
let result: ConnectorResult = rmp_serde::from_slice(&plaintext)?;
if result.schema_id != CONNECTOR_RESULT_SCHEMA || result.request_id != envelope.request_id {
bail!("model connector encrypted result substituted request identity")
}
Ok(result)
}
fn observed_output(
request_id: &str,
events: Vec<ConnectorModelEvent>,
) -> Result<ModelProviderOutput> {
let mut content = String::new();
let mut receipt = None;
for (index, event) in events.into_iter().enumerate() {
if event.schema_id != MODEL_EVENT_SCHEMA
|| event.request_id != request_id
|| event.provider != "openai-codex"
|| event.sequence != index as u64
|| receipt.is_some()
{
bail!("model connector returned an invalid event sequence")
}
match event.payload {
ConnectorModelPayload::TextDelta { text } => content.push_str(&text),
ConnectorModelPayload::Completed { receipt: completed } => receipt = Some(completed),
ConnectorModelPayload::Failed { message } => {
bail!("model connector provider failed: {message}")
}
ConnectorModelPayload::ReasoningDelta { .. }
| ConnectorModelPayload::ToolCall { .. } => {
bail!("model connector exposed a private or unsupported event")
}
}
}
let receipt = receipt.context("model connector response had no completion receipt")?;
if receipt.schema_id != MODEL_RECEIPT_SCHEMA
|| receipt.request_id != request_id
|| receipt.provider != "openai-codex"
{
bail!("model connector completion receipt substituted identity")
}
let prompt_tokens = receipt.input_tokens.unwrap_or_default();
let completion_tokens = receipt.output_tokens.unwrap_or_default();
let cache_hits = receipt.cached_input_tokens.unwrap_or_default();
Ok(ModelProviderOutput {
content,
resolved_model: Some(receipt.model),
provider_request_id: receipt.provider_response_id,
system_fingerprint: None,
finish_reason: Some("completed".to_string()),
token_usage: Some(ModelTokenUsage {
prompt_tokens,
completion_tokens,
total_tokens: prompt_tokens.saturating_add(completion_tokens),
prompt_cache_hit_tokens: cache_hits,
prompt_cache_miss_tokens: prompt_tokens.saturating_sub(cache_hits),
reasoning_tokens: receipt.reasoning_output_tokens.unwrap_or_default(),
}),
transport_features: vec![
"cultnet.tcp-framed".to_string(),
"cultmesh.provider:epiphany.codex-model".to_string(),
receipt
.transport
.unwrap_or_else(|| "epiphany-codex-transport".to_string()),
],
})
}
fn prompt_cache_key(request: &ModelStageRequest) -> Result<String> {
let schema = request
.output_schema
.as_ref()
.map(serde_json::to_vec)
.transpose()?
.unwrap_or_default();
let digest = Sha256::digest(
[
request.stage.as_bytes(),
&[0],
request.model.as_bytes(),
&[0],
&schema,
]
.concat(),
);
Ok(format!("ghostlight:{:x}", digest))
}
fn unix_ms() -> Result<u64> {
Ok(SystemTime::now()
.duration_since(UNIX_EPOCH)
.context("system clock predates Unix epoch")?
.as_millis()
.try_into()
.context("system clock does not fit u64 milliseconds")?)
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::TcpListener;
#[tokio::test]
async fn cultmesh_model_port_round_trips_typed_encrypted_cultnet_cargo() -> Result<()> {
let listener = TcpListener::bind("127.0.0.1:0")?;
let endpoint = listener.local_addr()?;
let security = CultNetClientSecurityOptions::new("connector-test-key")?;
let server_security = security.clone();
let server = std::thread::spawn(move || -> Result<ConnectorInvocation> {
let (stream, _) = listener.accept()?;
let profile = create_tcp_framed_transport_profile(
"test-connector",
TcpFramedTransportProfileOptions {
max_payload_bytes: Some(MAX_PAYLOAD_BYTES),
..TcpFramedTransportProfileOptions::default()
},
);
let mut connection = TcpFramedTransportConnection::new(stream, profile);
let frame = connection.receive()?;
let message = decode_cultnet_message_from_slice(
&frame.payload,
CultNetWireContract::CultNetSchemaV0,
)?;
let CultNetMessage::DocumentPutRaw { document, .. } = message else {
bail!("expected raw invocation")
};
let envelope: ConnectorEnvelope = rmp_serde::from_slice(&document.payload)?;
let plaintext = CultNetSecret::decrypt_bytes(
&envelope.ciphertext,
&envelope.nonce,
&server_security,
)?;
let invocation: ConnectorInvocation = rmp_serde::from_slice(&plaintext)?;
let result = ConnectorResult {
schema_id: CONNECTOR_RESULT_SCHEMA.to_string(),
request_id: invocation.request_id.clone(),
accepted: true,
events: vec![
ConnectorModelEvent {
schema_id: MODEL_EVENT_SCHEMA.to_string(),
request_id: invocation.request_id.clone(),
provider: "openai-codex".to_string(),
sequence: 0,
payload: ConnectorModelPayload::TextDelta {
text: "{\"answer\":\"ready\"}".to_string(),
},
},
ConnectorModelEvent {
schema_id: MODEL_EVENT_SCHEMA.to_string(),
request_id: invocation.request_id.clone(),
provider: "openai-codex".to_string(),
sequence: 1,
payload: ConnectorModelPayload::Completed {
receipt: ConnectorModelReceipt {
schema_id: MODEL_RECEIPT_SCHEMA.to_string(),
request_id: invocation.request_id.clone(),
provider: "openai-codex".to_string(),
model: "gpt-5.4".to_string(),
provider_response_id: Some("response-1".to_string()),
input_tokens: Some(100),
output_tokens: Some(10),
reasoning_output_tokens: Some(3),
transport: Some("epiphany_direct_responses_http".to_string()),
cached_input_tokens: Some(80),
},
},
},
],
error: None,
};
let nonce = CultNetSecret::new_nonce();
let plaintext = rmp_serde::to_vec_named(&result)?;
let envelope = ConnectorEnvelope {
schema_id: CONNECTOR_ENVELOPE_SCHEMA.to_string(),
request_id: invocation.request_id.clone(),
message_kind: RESULT_KIND.to_string(),
ciphertext: CultNetSecret::encrypt_bytes(&plaintext, &nonce, &server_security)?,
nonce: nonce.to_vec(),
};
let document = CultNetRawDocumentRecord {
schema_id: CONNECTOR_ENVELOPE_SCHEMA.to_string(),
record_key: invocation.request_id.clone(),
stored_at: "2026-08-24T00:00:00Z".to_string(),
payload_encoding: CultNetRawPayloadEncoding::Messagepack,
payload: rmp_serde::to_vec_named(&envelope)?,
source_runtime_id: Some("test-connector".to_string()),
source_agent_id: None,
source_role: Some("model-provider-connector".to_string()),
tags: None,
};
let payload = encode_cultnet_message_to_vec(
&CultNetMessage::SnapshotResponseRaw {
message_id: invocation.request_id.clone(),
documents: vec![document],
},
CultNetWireContract::CultNetSchemaV0,
)?;
connection.send("schema", &payload)?;
Ok(invocation)
});
let port = CultMeshModelPort::new(
endpoint,
"connector-test-key".to_string(),
"ghostlight-dungeon-yggdrasil",
"gpt-5.4",
"gpt-5.4",
)?;
let output = port
.run_observed(&ModelStageRequest {
stage: "test_interpreter".to_string(),
model: MODEL_CAPABLE.to_string(),
snapshot_binding: "revision:7".to_string(),
lived_stream: "Return the typed answer.".to_string(),
output_schema: Some(serde_json::json!({
"type": "object",
"required": ["answer"],
"properties": {"answer": {"type": "string"}},
"additionalProperties": false
})),
source_receipt_ids: Vec::new(),
temperature: Some(0.0),
max_output_tokens: Some(512),
})
.await?;
let invocation = server.join().expect("server thread")?;
assert_eq!(invocation.caller_runtime_id, "ghostlight-dungeon-yggdrasil");
assert_eq!(invocation.request.model, "gpt-5.4");
assert_eq!(invocation.request.max_output_tokens, Some(512));
assert!(invocation.request.prompt_cache_key.is_some());
assert_eq!(output.content, "{\"answer\":\"ready\"}");
assert_eq!(
output.token_usage.expect("usage").prompt_cache_hit_tokens,
80
);
Ok(())
}
#[test]
fn event_sequence_refuses_reasoning_and_missing_terminal_receipts() {
let reasoning = ConnectorModelEvent {
schema_id: MODEL_EVENT_SCHEMA.to_string(),
request_id: "request-1".to_string(),
provider: "openai-codex".to_string(),
sequence: 0,
payload: ConnectorModelPayload::ReasoningDelta {
text: "private".to_string(),
},
};
assert!(observed_output("request-1", vec![reasoning]).is_err());
assert!(observed_output("request-1", Vec::new()).is_err());
}
#[test]
fn cache_key_tracks_stable_stage_contract_not_dynamic_world_context() -> Result<()> {
let request = ModelStageRequest {
stage: "cell_interpreter".to_string(),
model: MODEL_CAPABLE.to_string(),
snapshot_binding: "revision:7".to_string(),
lived_stream: "A changing world slice.".to_string(),
output_schema: Some(serde_json::json!({
"type": "object",
"properties": {"action": {"type": "string"}}
})),
source_receipt_ids: vec!["receipt:one".to_string()],
temperature: Some(0.3),
max_output_tokens: Some(512),
};
let mut changed_context = request.clone();
changed_context.snapshot_binding = "revision:8".to_string();
changed_context.lived_stream = "A different world slice.".to_string();
changed_context.source_receipt_ids = vec!["receipt:two".to_string()];
assert_eq!(
prompt_cache_key(&request)?,
prompt_cache_key(&changed_context)?
);
let mut changed_contract = request.clone();
changed_contract.stage = "persona".to_string();
assert_ne!(
prompt_cache_key(&request)?,
prompt_cache_key(&changed_contract)?
);
Ok(())
}
}

View file

@ -812,10 +812,25 @@ Model allocation is provider-neutral inside Ghostlight. Stages request the
logical classes `ghostlight.fast.v1` or `ghostlight.capable.v1`; the selected
provider port alone maps those classes to physical model IDs. Receipts record
the resolved provider and physical model so a routing change cannot masquerade
as the same inference. The current Yggdrasil test profile maps both classes to
OpenRouter `stealth/ox-alpha`, using low reasoning for fast stages and high
reasoning for capable stages. OpenRouter is instructed to exclude reasoning
from its response, and the decoder never reads or retains that field.
as the same inference.
The `epiphany-codex` profile maps both logical classes to an operator-admitted
Codex model through Epiphany's independently supervised model connector. The
Ghostlight port constructs the native model request, exact output schema,
reasoning-effort hint, maximum output budget, and a stable prompt-cache key;
then it sends an expiring encrypted MessagePack invocation through bounded
TCP-framed CultNet on loopback. It validates every outer and inner request ID,
schema, provider, sequence, terminal receipt, and absence of reasoning/tool
events before returning output to the stage owner. Epiphany owns only Codex
credential custody, provider lowering, physical concurrency, and transport
receipts. It does not see campaign stores, run its Mind or swarm, interpret
results, or admit world state. Ghostlight cannot read the Codex credential and
the connector cannot commit a campaign mutation.
OpenRouter remains a supported test profile. It can map both classes to
`stealth/ox-alpha`, using low reasoning for fast stages and high reasoning for
capable stages. OpenRouter is instructed to exclude reasoning from its
response, and the decoder never reads or retains that field.
DeepSeek remains a supported provider profile: its flash model serves the fast
class and its pro model serves the capable class with thinking disabled. A
@ -848,6 +863,15 @@ same installed body through Idunn continuity. Changing the artifact,
configuration, schema, unit, or authority binding remains a separate
deployment operation.
The Epiphany model connector, when selected, is a distinct Idunn-managed
loopback service at `127.0.0.1:4103`. Its shared connection key is readable by
the connector and Ghostlight service identities; its Codex home is readable
only by the connector identity. Neither secret appears in service arguments,
Odin, CultMesh status, health, or release directories. Odin receives only the
redacted `model.generate.structured` capability advertisement. The connector
is not part of Epiphany's swarm release and does not wake or bypass a braked
Epiphany runtime.
The binary owns its build provenance. Release tooling injects the clean-tree
commit through `GHOSTLIGHT_BUILD_COMMIT`; local builds derive it from Git while
the build script watches `HEAD`, its symbolic branch ref, the HEAD reflog, and

View file

@ -203,6 +203,16 @@ the planner already owns. Stable prompt prefixes are deliberately placed before
dynamic state, and provider receipts expose per-attempt token/cache usage plus
bounded local validation failures.
`ModelPort` remains Ghostlight's single inference seam. The
`epiphany-codex` implementation is an ordinary typed consumer of Epiphany's
loopback model-provider connector: it emits an encrypted, expiring MessagePack
request over bounded TCP-framed CultNet and accepts only a correlated ordered
text stream plus terminal receipt. A stable cache key is derived from stage,
logical model class, and output schema rather than mutable campaign content.
Epiphany owns Codex credential custody and physical calls; Ghostlight still
owns stage projection, schemas, retries, semantic validation, receipts, and all
kernel admission. Neither side can borrow the other's state authority.
Canonical actor cell slices include that actor's exact goals, obligations,
relationships, and bounded memories. Named Gestalt-member exceptions receive
the same continuity fields. The Projector narrativizes them for the Persona;

View file

@ -258,6 +258,24 @@ where
let mut header = [0_u8; FRAME_HEADER_BYTES];
self.stream.read_exact(&mut header)?;
let payload_len = u32::from_be_bytes(header) as usize;
if let Some(max_payload_bytes) = self
.profile
.transports
.iter()
.find(|transport| transport.protocol == CultNetTransportProtocol::TcpFramed)
.and_then(|transport| {
transport
.channels
.iter()
.find(|channel| channel.channel_id == "schema")
})
.and_then(|channel| channel.max_payload_bytes)
&& payload_len > max_payload_bytes as usize
{
return Err(anyhow!(
"tcp_framed payload length {payload_len} exceeds advertised maximum {max_payload_bytes}"
));
}
let mut payload = vec![0_u8; payload_len];
self.stream.read_exact(&mut payload)?;
self.stats.bytes_received += (FRAME_HEADER_BYTES + payload_len) as u64;

View file

@ -307,6 +307,23 @@ fn tcp_framed_transport_carries_schema_payloads_with_stats() -> Result<()> {
Ok(())
}
#[test]
fn tcp_framed_transport_rejects_oversized_payload_before_reading_it() {
let profile = create_tcp_framed_transport_profile(
"bounded-rust-transport",
TcpFramedTransportProfileOptions {
max_payload_bytes: Some(8),
..TcpFramedTransportProfileOptions::default()
},
);
let mut bytes = Vec::new();
bytes.extend_from_slice(&9_u32.to_be_bytes());
let mut receiver = TcpFramedTransportConnection::new(std::io::Cursor::new(bytes), profile);
let error = receiver.receive().expect_err("oversized frame must fail");
assert!(error.to_string().contains("exceeds advertised maximum 8"));
assert_eq!(receiver.stats().bytes_received, 0);
}
#[test]
fn rudp_packet_codec_uses_deterministic_reliable_ordered_fixture() -> Result<()> {
let encoded = encode_rudp_packet(&CultNetRudpPacket {